Add wIRC main scrollback, route services to it, remember window bounds, bump to 0.1.7

wIRC main scrollback
- The main window now has a "Server messages" scrollback using the same
  rendering and stick-to-bottom code as channel windows (extracted from
  ChannelScreen into a shared MessageScrollback composable).
- MOTD, numerics, errors, connection status, user modes, INVITE, ERROR,
  non-ACTION CTCP requests and notices/messages from services
  (NickServ, ChanServ, *Serv, Global, ...) and the server go there. Its
  history persists like any other buffer (history/wirc-main__main.json).
- Unread indicator: lines arriving while the main window is unfocused
  show as "N new" next to the label and in the window title/taskbar.

Private messages and /whois
- A PM or notice from a real user opens its query window, and reopens it
  if it was closed. Services and the server no longer open windows.
- /whois <nick> sends WHOIS and shows the formatted reply in the window
  it was typed in, or in wIRC main if that window has since closed.
- /me now sends a proper CTCP ACTION (the \x01 wrapper was missing).

Window position and size
- Main, channel and PM windows remember position and size in
  window_prefs.json under the existing "<serverId>__<name>" key (main
  uses "wirc-main__main"). The new windowX/windowY/windowWidth/
  windowHeight fields are optional, so older files still load.
- A saved position is only used if the window's title strip is on a
  connected monitor; otherwise, and for windows with no saved position,
  windows cascade from the primary screen's top-left with a 32dp offset.
- window_prefs.json is now written via a temp file + atomic move.

Cleanup
- Remove the TEMP DEBUG aliasDebug tracing, ServerRepository.upsert
  printlns and connmgr-debug printlns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.tpuahsiew.wirc"
-version = "0.1.6"
+version = "0.1.7"
 
 // No project-level repositories{} block here: settings.gradle.kts sets
 // dependencyResolutionManagement.repositoriesMode = FAIL_ON_PROJECT_REPOS and already
@@ -38,7 +38,7 @@ compose.desktop {
             appResourcesRootDir.set(project.file("installerResources"))
             targetFormats(TargetFormat.Msi, TargetFormat.Exe)
             packageName = "wIRC"
-            packageVersion = "0.1.6"
+            packageVersion = "0.1.7"
             windows {
                 menuGroup = "wIRC"
                 upgradeUuid = "8f14e45f-ceea-4a5e-9c3b-5b1f0e8c2b7a"

src/main/kotlin/Main.kt

@@ -2,6 +2,7 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.darkColorScheme
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateOf
@@ -9,16 +10,20 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
-import androidx.compose.ui.window.rememberWindowState
 import data.AliasRepository
 import data.BufferKey
+import data.MAIN_BUFFER_KEY
 import data.ServerRepository
 import data.WindowPrefsRepository
+import data.storageId
 import irc.ConnectionManager
 import ui.ChannelWindow
 import ui.MainScreen
+import ui.rememberPersistentWindowState
 import java.io.File
 
 // Material 3's darkColorScheme() defaults to a purple accent; this keeps everything
@@ -51,6 +56,13 @@ fun main() = application {
     val prefsRepo = remember { WindowPrefsRepository(appRoot) }
 
     var openBuffers by remember { mutableStateOf(setOf<BufferKey>()) }
+    var mainUnread by remember { mutableStateOf(0) }
+
+    // ConnectionManager routes WHOIS replies to the window that asked only while that
+    // window is still open, so it needs to know which ones are.
+    LaunchedEffect(openBuffers) {
+        ConnectionManager.openWindows = openBuffers
+    }
 
     // Full shutdown: same steps /quit (bare, no args) already runs from a channel window -
     // disconnect every server, then end the process. Shared here so the "Exit wIRC" button
@@ -65,31 +77,44 @@ fun main() = application {
     // ConnectionManager's sockets just live for as long as this process runs, and this
     // listener (which the Android foreground service used to own) can live directly at
     // the application level instead.
+    //
+    // Fires for every private message to or from a real user, so a query window the user
+    // closed reopens when that person messages again. Adding a key that's already open is
+    // a no-op (openBuffers is a set).
     LaunchedEffect(Unit) {
-        ConnectionManager.newQueryBuffers.collect { key ->
+        ConnectionManager.queryWindowRequests.collect { key ->
             openBuffers = openBuffers + key
         }
     }
 
+    // Restored from / saved to window_prefs.json under MAIN_BUFFER_KEY's storage id
+    // ("wirc-main__main"), same as every channel and PM window - see WindowPlacement.kt.
+    val mainWindowState = rememberPersistentWindowState(prefsRepo, MAIN_BUFFER_KEY.storageId(), DpSize(800.dp, 700.dp))
+    val mainDisplaySettings by prefsRepo.settingsFor(MAIN_BUFFER_KEY.storageId()).collectAsState()
+
     // There's no persistent tray/notification surface on this build, so closing the main
     // server-list window quits the whole app (and every channel window with it) - the
     // same "closing the primary window ends the session" convention most desktop chat
     // apps without a tray icon follow.
     Window(
         onCloseRequest = ::exitApplication,
-        title = "wIRC - Main",
+        // The unread count shows in the taskbar too, so new server messages are visible
+        // even when the main window is behind other windows.
+        title = if (mainUnread > 0) "wIRC - Main ($mainUnread new)" else "wIRC - Main",
         icon = painterResource("icon.png"),
-        state = rememberWindowState()
+        state = mainWindowState
     ) {
         MaterialTheme(colorScheme = neutralDarkScheme) {
             Surface {
                 MainScreen(
                     repo = repo,
                     colorScheme = neutralDarkScheme,
+                    displaySettings = mainDisplaySettings,
                     onOpenChannel = { serverId, channelName ->
                         openBuffers = openBuffers + BufferKey(serverId, channelName)
                     },
-                    onExitApp = shutdownApp
+                    onExitApp = shutdownApp,
+                    onUnreadChange = { mainUnread = it }
                 )
             }
         }

src/main/kotlin/data/AliasRepository.kt

@@ -5,13 +5,6 @@ import java.io.File
 import java.net.URI
 import java.net.URLEncoder
 
-// TEMP DEBUG (see task: alias multi-word arguments investigation) - remove once confirmed
-// fixed. Traces the full alias pipeline: raw input -> matched alias -> substituted target
-// -> the actual Desktop API call, so a silent failure anywhere in that chain is visible.
-private fun aliasDebug(msg: String) {
-    println("[alias-debug] $msg")
-}
-
 // Name reserved for the app-level /reload command (ChannelWindow.kt handles it directly,
 // before alias lookup even runs) - kept here too so a line in aliases.txt can never define
 // an alias that would shadow it.
@@ -64,15 +57,9 @@ object AliasRepository {
      * "reload" name, which this repository never loads as an alias).
      */
     fun tryRunAlias(command: String, args: String): Boolean {
-        aliasDebug("tryRunAlias: command=\"$command\" args=\"$args\"")
         val key = command.lowercase()
         if (key == RESERVED_RELOAD) return false
-        val action = aliases[key]
-        if (action == null) {
-            aliasDebug("no alias matched for \"$key\"")
-            return false
-        }
-        aliasDebug("matched \"$key\" -> \"$action\"")
+        val action = aliases[key] ?: return false
         runAction(action, args)
         return true
     }
@@ -94,13 +81,12 @@ object AliasRepository {
         // literal, not a URL delimiter.
         val substitutedArg = if (type == "url") encodeArgForUrl(args) else args
         val target = if (rawTarget.contains("{arg}")) rawTarget.replace("{arg}", substitutedArg) else rawTarget
-        aliasDebug("type=\"$type\" rawTarget=\"$rawTarget\" substitutedArg=\"$substitutedArg\" -> target=\"$target\"")
         if (target.isBlank()) return
 
         try {
             when (type) {
-                "path" -> { aliasDebug("Desktop.open(File(\"$target\"))"); Desktop.getDesktop().open(File(target)) }
-                "url" -> { aliasDebug("Desktop.browse(URI(\"$target\"))"); Desktop.getDesktop().browse(URI(target)) }
+                "path" -> Desktop.getDesktop().open(File(target))
+                "url" -> Desktop.getDesktop().browse(URI(target))
                 // Routed through "cmd /c start" (same launch path as double-clicking in
                 // Explorer or the Run dialog) rather than exec'd directly. A direct
                 // ProcessBuilder(target).start() calls CreateProcess, which does NOT honor
@@ -110,7 +96,7 @@ object AliasRepository {
                 // would. This also preserves bare-name resolution via Windows' App Paths
                 // registry / PATH - not guaranteed to work for every app, since it depends
                 // on that app having registered itself with Windows.
-                "run" -> { aliasDebug("ProcessBuilder start \"$target\""); ProcessBuilder("cmd", "/c", "start", "\"\"", target).start() }
+                "run" -> ProcessBuilder("cmd", "/c", "start", "\"\"", target).start()
                 else -> println("[AliasRepository] Unknown alias action type '$type' in \"$action\"")
             }
         } catch (e: Exception) {

src/main/kotlin/data/Models.kt

@@ -47,6 +47,35 @@ data class IrcMessage(
 /** Buffer key: server id + channel/query name (channel names include '#'). */
 data class BufferKey(val serverId: String, val name: String)
 
+/**
+ * wIRC main's own buffer: server messages (MOTD, numerics, errors, whois fallback) and
+ * services/server notices from every connected server. Server ids are built from the host
+ * with every non-alphanumeric character replaced by '_' (see ServerEditDialog), so one can
+ * never contain '-' - this id can't collide with a real server. Also used as the
+ * window_prefs.json key ("wirc-main__main") for the main window's saved position and size.
+ */
+val MAIN_BUFFER_KEY = BufferKey("wirc-main", "main")
+
+// Nicks that are network services rather than people. Their PRIVMSGs and NOTICEs go to
+// wIRC main instead of opening a query window. Anything ending in "serv" is also treated
+// as a service, which covers the less common ones (MemoServ, HostServ, SaslServ, ...).
+private val KNOWN_SERVICE_NICKS = setOf("nickserv", "chanserv", "global", "alis", "q", "x")
+
+fun isServiceNick(nick: String): Boolean {
+    val lower = nick.lowercase()
+    return lower in KNOWN_SERVICE_NICKS || lower.endsWith("serv")
+}
+
+/**
+ * True when a message's source is a service or the server itself rather than a real user.
+ * A user prefix always has the "nick!user@host" form; a missing prefix or one without '!'
+ * is a server name (e.g. "irc.rizon.io").
+ */
+fun isServiceOrServerPrefix(prefix: String?): Boolean {
+    if (prefix == null || !prefix.contains('!')) return true
+    return isServiceNick(prefix.substringBefore('!'))
+}
+
 data class ChannelUser(
     val nick: String,
     val isOp: Boolean = false,

src/main/kotlin/data/ServerRepository.kt

@@ -42,16 +42,10 @@ class ServerRepository(rootDir: File) {
     }
 
     fun upsert(server: ServerConfig) {
-        // TEMP DEBUG (see task: on-connect identify command investigation) - confirms the
-        // Edit Server dialog's Save actually persists onConnectCommands, by writing then
-        // immediately re-reading the file back rather than trusting the in-memory value.
-        println("[ServerRepository] upsert(${server.id}): saving onConnectCommands=${server.onConnectCommands}")
         val current = loadAll().toMutableList()
         val idx = current.indexOfFirst { it.id == server.id }
         if (idx >= 0) current[idx] = server else current.add(server)
         saveAll(current)
-        val reloaded = loadAll().firstOrNull { it.id == server.id }
-        println("[ServerRepository] upsert(${server.id}): reloaded from disk onConnectCommands=${reloaded?.onConnectCommands}")
     }
 
     fun remove(serverId: String) {

src/main/kotlin/data/WindowPrefsRepository.kt

@@ -5,6 +5,9 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import org.json.JSONObject
 import java.io.File
+import java.nio.file.AtomicMoveNotSupportedException
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
 import java.util.concurrent.ConcurrentHashMap
 
 data class WindowDisplaySettings(
@@ -17,19 +20,41 @@ data class WindowDisplaySettings(
     val showImagePreviews: Boolean = false   // opt-in: auto-loading images reveals your IP to the host
 )
 
+/**
+ * A window's last floating position and size, in dp (which Compose Desktop maps 1:1 to
+ * AWT's logical screen coordinates). Every field is optional in window_prefs.json, so files
+ * written before this existed still load - a window with no saved bounds just gets a
+ * cascaded default (see ui/WindowPlacement.kt).
+ */
+data class WindowBounds(
+    val x: Float?,
+    val y: Float?,
+    val width: Float?,
+    val height: Float?
+)
+
 /**
  * Desktop equivalent of the Android DataStore-backed repository. Settings for every
  * buffer are kept as one JSON file (rootDir/window_prefs.json), keyed by buffer storage
  * id, loaded once at startup and rewritten on every change. Each buffer's settings are
  * exposed as a StateFlow so every open window for that buffer updates live, same as
  * DataStore's Flow did on Android.
+ *
+ * Window bounds live in the same JSON object per key (windowX/windowY/windowWidth/
+ * windowHeight) but are kept out of the display-settings StateFlow, so moving or resizing
+ * a window doesn't recompose its content.
  */
 class WindowPrefsRepository(rootDir: File) {
 
     private val file = File(rootDir, "window_prefs.json")
     private val lock = Any()
     private val flows = ConcurrentHashMap<String, MutableStateFlow<WindowDisplaySettings>>()
-    private var stored: MutableMap<String, WindowDisplaySettings> = loadAll()
+    private val stored = mutableMapOf<String, WindowDisplaySettings>()
+    private val storedBounds = mutableMapOf<String, WindowBounds>()
+
+    init {
+        loadAll()
+    }
 
     fun settingsFor(bufferKeyId: String): StateFlow<WindowDisplaySettings> = flowFor(bufferKeyId).asStateFlow()
 
@@ -47,8 +72,18 @@ class WindowPrefsRepository(rootDir: File) {
 
     fun setShowImagePreviews(bufferKeyId: String, show: Boolean) = update(bufferKeyId) { it.copy(showImagePreviews = show) }
 
+    fun boundsFor(bufferKeyId: String): WindowBounds? = synchronized(lock) { storedBounds[bufferKeyId] }
+
+    fun setWindowBounds(bufferKeyId: String, bounds: WindowBounds) {
+        synchronized(lock) {
+            if (storedBounds[bufferKeyId] == bounds) return
+            storedBounds[bufferKeyId] = bounds
+            persist()
+        }
+    }
+
     private fun flowFor(bufferKeyId: String): MutableStateFlow<WindowDisplaySettings> =
-        flows.getOrPut(bufferKeyId) { MutableStateFlow(stored[bufferKeyId] ?: WindowDisplaySettings()) }
+        flows.getOrPut(bufferKeyId) { MutableStateFlow(synchronized(lock) { stored[bufferKeyId] } ?: WindowDisplaySettings()) }
 
     private fun update(bufferKeyId: String, transform: (WindowDisplaySettings) -> WindowDisplaySettings) {
         synchronized(lock) {
@@ -59,14 +94,16 @@ class WindowPrefsRepository(rootDir: File) {
         }
     }
 
-    private fun loadAll(): MutableMap<String, WindowDisplaySettings> {
-        if (!file.exists()) return mutableMapOf()
-        return try {
+    private fun JSONObject.optFloatOrNull(key: String): Float? =
+        if (has(key) && !isNull(key)) optDouble(key).toFloat().takeIf { !it.isNaN() } else null
+
+    private fun loadAll() {
+        if (!file.exists()) return
+        try {
             val obj = JSONObject(file.readText())
-            val result = mutableMapOf<String, WindowDisplaySettings>()
             obj.keys().forEach { key ->
                 val o = obj.getJSONObject(key)
-                result[key] = WindowDisplaySettings(
+                stored[key] = WindowDisplaySettings(
                     backgroundAlpha = o.optDouble("backgroundAlpha", 0.85).toFloat(),
                     textColorMircIndex = o.optInt("textColorMircIndex", 0),
                     fontSize = o.optDouble("fontSize", 14.0).toFloat(),
@@ -75,17 +112,29 @@ class WindowPrefsRepository(rootDir: File) {
                     nickColorsEnabled = o.optBoolean("nickColorsEnabled", true),
                     showImagePreviews = o.optBoolean("showImagePreviews", false)
                 )
+                val bounds = WindowBounds(
+                    x = o.optFloatOrNull("windowX"),
+                    y = o.optFloatOrNull("windowY"),
+                    width = o.optFloatOrNull("windowWidth"),
+                    height = o.optFloatOrNull("windowHeight")
+                )
+                if (bounds != WindowBounds(null, null, null, null)) storedBounds[key] = bounds
             }
-            result
         } catch (e: Exception) {
-            mutableMapOf()
+            stored.clear()
+            storedBounds.clear()
         }
     }
 
+    // Written to a temp file and moved into place, same as MessageHistoryRepository - this
+    // file is now rewritten every time a window is moved or resized, so a crash mid-write
+    // must not be able to leave a truncated file (which loadAll would read as "no settings
+    // at all" and the next save would make permanent).
     private fun persist() {
         val obj = JSONObject()
-        stored.forEach { (key, settings) ->
+        (stored.keys + storedBounds.keys).forEach { key ->
             obj.put(key, JSONObject().apply {
+                stored[key]?.let { settings ->
                     put("backgroundAlpha", settings.backgroundAlpha)
                     put("textColorMircIndex", settings.textColorMircIndex)
                     put("fontSize", settings.fontSize)
@@ -93,10 +142,23 @@ class WindowPrefsRepository(rootDir: File) {
                     put("mentionHighlightColorArgb", settings.mentionHighlightColorArgb)
                     put("nickColorsEnabled", settings.nickColorsEnabled)
                     put("showImagePreviews", settings.showImagePreviews)
+                }
+                storedBounds[key]?.let { bounds ->
+                    bounds.x?.let { put("windowX", it) }
+                    bounds.y?.let { put("windowY", it) }
+                    bounds.width?.let { put("windowWidth", it) }
+                    bounds.height?.let { put("windowHeight", it) }
+                }
             })
         }
         file.parentFile?.mkdirs()
-        file.writeText(obj.toString())
+        val tmp = File(file.parentFile, "${file.name}.tmp")
+        tmp.writeText(obj.toString())
+        try {
+            Files.move(tmp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
+        } catch (e: AtomicMoveNotSupportedException) {
+            Files.move(tmp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING)
+        }
     }
 }
 

src/main/kotlin/irc/ConnectionManager.kt

@@ -14,6 +14,9 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 import java.util.concurrent.ConcurrentHashMap
 
 // Per-buffer message history cap. Named so it's a one-line change to temporarily lower
@@ -28,6 +31,19 @@ private const val MESSAGE_HISTORY_CAP = 500
 // reported slowness under real message volume.
 private const val SAVE_DEBOUNCE_MS = 2500L
 
+// WHOIS reply numerics. Each one's params are [ourNick, targetNick, ...], so the target
+// nick (params[1]) is what ties a reply line back to the /whois that asked for it.
+// 318 is RPL_ENDOFWHOIS; 401/402 are the "no such nick/server" errors a WHOIS can get.
+private val WHOIS_NUMERICS = setOf(
+    "275", "276", "301", "307", "310", "311", "312", "313", "317", "318", "319",
+    "320", "330", "335", "338", "378", "379", "401", "402", "671"
+)
+
+// Numerics that only make sense inside a channel window and are already reflected there
+// (353 fills the user list, see handleLine) or carry nothing worth showing on their own -
+// kept out of wIRC main so joining a channel doesn't flood it.
+private val CHANNEL_ONLY_NUMERICS = setOf("332", "333", "353", "366")
+
 /**
  * App-wide singleton. Owns every IrcConnection and every ChannelBuffer, so that all
  * windows read from the same source of truth via StateFlow.
@@ -47,8 +63,19 @@ object ConnectionManager {
     private val _ownNicks = MutableStateFlow<Map<String, String>>(emptyMap())
     val ownNicksFlow: StateFlow<Map<String, String>> = _ownNicks
 
+    // Buffers that currently have a window open, kept up to date by Main.kt. Read when a
+    // WHOIS reply arrives, to decide whether the window that asked is still there to show it.
+    @Volatile
+    var openWindows: Set<BufferKey> = emptySet()
+
+    // serverId -> (lowercased target nick -> the buffer whose window typed the /whois).
+    private val pendingWhois = ConcurrentHashMap<String, ConcurrentHashMap<String, BufferKey>>()
+
     fun init(rootDir: File) {
         historyRepo = MessageHistoryRepository(rootDir)
+        // Seeds wIRC main from its saved history right away, so its scrollback is there at
+        // startup instead of appearing only once the first server line arrives.
+        enqueue { ensureBuffer(MAIN_BUFFER_KEY) }
     }
 
     private fun setOwnNick(serverId: String, nick: String) {
@@ -56,11 +83,12 @@ object ConnectionManager {
         _ownNicks.update { it + (serverId to nick) }
     }
 
-    // Fires once for every brand-new private-message buffer (a query with someone
-    // who wasn't already an open window). Main.kt listens to this to auto-open a
-    // window for it, same as clicking a channel manually.
-    private val _newQueryBuffers = MutableSharedFlow<BufferKey>(extraBufferCapacity = 16)
-    val newQueryBuffers: SharedFlow<BufferKey> = _newQueryBuffers
+    // Fires for every private message to or from a real user (services and the server go
+    // to wIRC main instead). Main.kt adds the key to its set of open windows, which opens
+    // the query window if it isn't open - including reopening one the user closed - and
+    // is a no-op if it already is.
+    private val _queryWindowRequests = MutableSharedFlow<BufferKey>(extraBufferCapacity = 64)
+    val queryWindowRequests: SharedFlow<BufferKey> = _queryWindowRequests
 
     // Every buffer state change - incoming lines, local echoes of our own sends - goes
     // through this single FIFO queue, processed by one consumer coroutine. Previously each
@@ -92,10 +120,6 @@ object ConnectionManager {
     }
 
     fun connect(config: ServerConfig) {
-        // TEMP DEBUG (see task: on-connect identify command investigation) - confirms
-        // whether the config this connect() call actually received has the on-connect
-        // commands the caller thinks it saved.
-        println("[connmgr-debug] connect(${config.id}) called - onConnectCommands=${config.onConnectCommands}")
         val existing = connections[config.id]
         if (existing != null) {
             // This used to just `return` here, making connect() a permanent no-op for the
@@ -105,7 +129,6 @@ object ConnectionManager {
             // `config` was captured once at construction and never replaced. Tearing down
             // the old connection and replacing it means a connect() call always actually
             // uses whatever was most recently saved.
-            println("[connmgr-debug] connect(${config.id}) - already connected, replacing with a fresh connection using the latest config")
             existing.disconnect()
         }
         setOwnNick(config.id, config.nick)
@@ -113,7 +136,11 @@ object ConnectionManager {
             config = config,
             scope = scope,
             onLine = { line -> enqueue { handleLine(config.id, line) } },
-            onStatus = { msg -> _statuses.update { it + (config.id to msg) } }
+            onStatus = { msg ->
+                _statuses.update { it + (config.id to msg) }
+                // Connection progress and errors aren't tied to any channel - wIRC main.
+                enqueue { addMainLine(MessageKind.SYSTEM, null, "[${config.label}] $msg") }
+            }
         )
         connections[config.id] = conn
         conn.connect()
@@ -133,20 +160,32 @@ object ConnectionManager {
     fun sendChannelMessage(serverId: String, target: String, text: String) {
         connectionFor(serverId)?.sendMessage(target, text)
         val myNick = ownNicks[serverId] ?: return
-        val key = BufferKey(serverId, target)
         val msg = IrcMessage(System.currentTimeMillis(), MessageKind.CHAT, myNick, text)
-        enqueue { addMessage(key, msg) }
+        enqueue { addOutgoing(serverId, target, msg, "-> *$target* $text") }
     }
 
     // Same local-echo problem as sendChannelMessage, but for /me: the wire form is a
     // CTCP ACTION wrapper, while the buffer should just hold the plain action text
     // (ChannelScreen renders MessageKind.ACTION with its own "* nick ..." prefix).
     fun sendChannelAction(serverId: String, target: String, action: String) {
-        connectionFor(serverId)?.sendMessage(target, "ACTION $action")
+        connectionFor(serverId)?.sendMessage(target, "\u0001ACTION $action\u0001")
         val myNick = ownNicks[serverId] ?: return
-        val key = BufferKey(serverId, target)
         val msg = IrcMessage(System.currentTimeMillis(), MessageKind.ACTION, myNick, action)
-        enqueue { addMessage(key, msg) }
+        enqueue { addOutgoing(serverId, target, msg, "-> *$target* * $myNick $action") }
+    }
+
+    // Where a local echo goes: a channel's own buffer, wIRC main for a service (e.g.
+    // "/msg NickServ ..."), or a query buffer - opening its window - for a real user.
+    private fun addOutgoing(serverId: String, target: String, msg: IrcMessage, mainText: String) {
+        when {
+            isChannelName(target) -> addMessage(BufferKey(serverId, target), msg)
+            isServiceNick(target) -> addMainLine(MessageKind.SYSTEM, null, mainText)
+            else -> {
+                val key = BufferKey(serverId, target)
+                addMessage(key, msg)
+                _queryWindowRequests.tryEmit(key)
+            }
+        }
     }
 
     // Raw passthrough for slash commands that don't have dedicated handling.
@@ -154,6 +193,22 @@ object ConnectionManager {
         connectionFor(serverId)?.send(raw)
     }
 
+    /**
+     * Sends WHOIS and remembers which window asked, so the reply lines are shown in that
+     * window - or in wIRC main if it has been closed by the time they arrive. [args] is
+     * whatever followed "/whois"; its last word is the nick being looked up (the
+     * "/whois server nick" form puts the nick last too).
+     */
+    fun whois(serverId: String, args: String, origin: BufferKey) {
+        val nick = args.trim().split(Regex("\\s+")).lastOrNull()?.takeIf { it.isNotEmpty() }
+        if (nick == null) {
+            addSystemMessage(serverId, origin.name, "Usage: /whois <nick>")
+            return
+        }
+        pendingWhois.getOrPut(serverId) { ConcurrentHashMap() }[nick.lowercase()] = origin
+        sendRaw(serverId, "WHOIS ${args.trim()}")
+    }
+
     // Local-only feedback (e.g. the /reload confirmation) that never touches the
     // wire - just appended to the buffer the same way any other SYSTEM line is.
     fun addSystemMessage(serverId: String, target: String, text: String) {
@@ -177,12 +232,6 @@ object ConnectionManager {
         if (_buffers.value.containsKey(key)) return
         val seeded = historyRepo?.loadMessages(key) ?: emptyList()
         _buffers.update { map -> map + (key to ChannelBuffer(key, messages = seeded)) }
-        if (!isChannelName(key.name)) {
-            // tryEmit, not emit: this runs on the single, non-suspend bufferOps consumer,
-            // not its own coroutine, so there's nothing to suspend into. The SharedFlow's
-            // 16-slot extraBufferCapacity means this can't actually fail in practice.
-            _newQueryBuffers.tryEmit(key)
-        }
     }
 
     private fun addMessage(key: BufferKey, msg: IrcMessage) {
@@ -195,6 +244,10 @@ object ConnectionManager {
         scheduleSave(key)
     }
 
+    private fun addMainLine(kind: MessageKind, sender: String?, text: String) {
+        addMessage(MAIN_BUFFER_KEY, IrcMessage(System.currentTimeMillis(), kind, sender, text))
+    }
+
     // Coalesces rapid-fire saves for the same buffer into at most one write every
     // SAVE_DEBOUNCE_MS, instead of a full history save (up to 500 messages) on every single
     // incoming message - the direct cause of reported slowness in a busy channel. Reads
@@ -229,6 +282,57 @@ object ConnectionManager {
         }
     }
 
+    // A WHOIS reply line goes to the window that typed the /whois if it's still open,
+    // otherwise (closed since, or a WHOIS nobody asked for here) to wIRC main.
+    private fun handleWhoisLine(serverId: String, line: ParsedLine) {
+        val target = line.params.getOrNull(1) ?: return
+        val pending = pendingWhois[serverId]
+        val origin = pending?.get(target.lowercase())
+        if (line.command == "318") pending?.remove(target.lowercase())
+
+        val text = "[whois] " + formatWhoisLine(line)
+        val msg = IrcMessage(System.currentTimeMillis(), MessageKind.SYSTEM, null, text)
+        if (origin != null && origin in openWindows) addMessage(origin, msg) else addMessage(MAIN_BUFFER_KEY, msg)
+    }
+
+    private fun formatWhoisLine(line: ParsedLine): String {
+        val p = line.params
+        val nick = p.getOrNull(1) ?: ""
+        return when (line.command) {
+            "311" -> "$nick is ${p.getOrNull(2)}@${p.getOrNull(3)} (${p.lastOrNull() ?: ""})"
+            "312" -> "$nick is on ${p.getOrNull(2)} (${p.lastOrNull() ?: ""})"
+            "317" -> {
+                val idleSecs = p.getOrNull(2)?.toLongOrNull()
+                val signon = p.getOrNull(3)?.toLongOrNull()
+                buildString {
+                    append("$nick has been idle ${idleSecs?.let { formatDuration(it) } ?: "?"}")
+                    if (signon != null) {
+                        val fmt = SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault())
+                        append(", signed on ${fmt.format(Date(signon * 1000))}")
+                    }
+                }
+            }
+            "319" -> "$nick is on channels: ${p.lastOrNull() ?: ""}"
+            "330" -> "$nick ${p.lastOrNull() ?: "is logged in as"} ${p.getOrNull(2) ?: ""}".trim()
+            "301" -> "$nick is away: ${p.lastOrNull() ?: ""}"
+            "318" -> "End of WHOIS for $nick"
+            else -> p.drop(1).joinToString(" ")
+        }
+    }
+
+    private fun formatDuration(totalSecs: Long): String {
+        val d = totalSecs / 86400
+        val h = (totalSecs % 86400) / 3600
+        val m = (totalSecs % 3600) / 60
+        val s = totalSecs % 60
+        return buildString {
+            if (d > 0) append("${d}d ")
+            if (d > 0 || h > 0) append("${h}h ")
+            if (d > 0 || h > 0 || m > 0) append("${m}m ")
+            append("${s}s")
+        }
+    }
+
     private fun handleLine(serverId: String, line: ParsedLine) {
         val now = System.currentTimeMillis()
         val nick = nickFromPrefix(line.prefix) ?: line.prefix
@@ -237,16 +341,46 @@ object ConnectionManager {
             "PRIVMSG" -> {
                 val target = line.params.getOrNull(0) ?: return
                 val text = line.params.getOrNull(1) ?: return
-                val isAction = text.startsWith("
ACTION") && text.endsWith("
")
-                val body = if (isAction) text.removePrefix("
ACTION ").removeSuffix("
") else text
-                // Channel messages are keyed by the channel name. Private messages arrive
-                // with target == our own nick, so key those by the *sender* instead -
-                // that's the conversation identity a query window should use.
-                val bufferName = if (isChannelName(target)) target else (nick ?: target)
+                val isCtcp = text.length > 1 && text.startsWith("\u0001") && text.endsWith("\u0001")
+                val isAction = isCtcp && text.startsWith("\u0001ACTION")
+                val body = if (isAction) text.removePrefix("\u0001ACTION ").removeSuffix("\u0001") else text
+                if (isChannelName(target)) {
                     addMessage(
-                    BufferKey(serverId, bufferName),
+                        BufferKey(serverId, target),
                         IrcMessage(now, if (isAction) MessageKind.ACTION else MessageKind.CHAT, nick, body)
                     )
+                } else if (isServiceOrServerPrefix(line.prefix) || (isCtcp && !isAction)) {
+                    // Services, the server itself, and CTCP requests other than ACTION
+                    // (PING, TIME, ...) go to wIRC main instead of opening a query window.
+                    // (VERSION is already answered and swallowed in IrcConnection.)
+                    val shown = if (isCtcp && !isAction) "[CTCP ${text.trim('\u0001')} from $nick]" else body
+                    addMainLine(MessageKind.CHAT, nick, shown)
+                } else {
+                    // A private message from a real user arrives with target == our own
+                    // nick, so key it by the *sender* - that's the conversation identity a
+                    // query window should use - and (re)open that window.
+                    val key = BufferKey(serverId, nick ?: target)
+                    addMessage(key, IrcMessage(now, if (isAction) MessageKind.ACTION else MessageKind.CHAT, nick, body))
+                    _queryWindowRequests.tryEmit(key)
+                }
+            }
+            "NOTICE" -> {
+                val target = line.params.getOrNull(0) ?: return
+                val text = line.params.getOrNull(1) ?: return
+                if (isChannelName(target)) {
+                    addMessage(BufferKey(serverId, target), IrcMessage(now, MessageKind.NOTICE, nick, text))
+                } else if (isServiceOrServerPrefix(line.prefix)) {
+                    // NickServ/ChanServ replies (identify success/failure etc.) and server
+                    // notices - wIRC main. The sender goes into the text because the
+                    // NOTICE row layout doesn't show a nick column.
+                    addMainLine(MessageKind.NOTICE, nick, "-${nick ?: "server"}- $text")
+                } else {
+                    // A notice directed AT us arrives with target == our own nick, so key
+                    // it by the sender, same as a private message.
+                    val key = BufferKey(serverId, nick ?: target)
+                    addMessage(key, IrcMessage(now, MessageKind.NOTICE, nick, text))
+                    _queryWindowRequests.tryEmit(key)
+                }
             }
             "JOIN" -> {
                 val channel = line.params.getOrNull(0) ?: return
@@ -270,9 +404,13 @@ object ConnectionManager {
             }
             "MODE" -> {
                 val channel = line.params.getOrNull(0) ?: return
-                if (!channel.startsWith("#")) return
                 val modeStr = line.params.getOrNull(1) ?: ""
                 val modeTarget = line.params.getOrNull(2)
+                if (!isChannelName(channel)) {
+                    // User mode on our own nick (e.g. +i, +r after identifying) - wIRC main.
+                    addMainLine(MessageKind.MODE, nick, "$nick sets mode $modeStr on $channel")
+                    return
+                }
                 addMessage(
                     BufferKey(serverId, channel),
                     IrcMessage(now, MessageKind.MODE, nick, "$nick sets mode $modeStr ${modeTarget ?: ""}".trim())
@@ -315,20 +453,6 @@ object ConnectionManager {
                 }
                 updateUsers(BufferKey(serverId, channel)) { existing -> (existing + parsedUsers).distinctBy { it.nick } }
             }
-            "NOTICE" -> {
-                val target = line.params.getOrNull(0) ?: return
-                val text = line.params.getOrNull(1) ?: return
-                // Same fix PRIVMSG already had: a notice directed AT us arrives with
-                // target == our own nick, not the sender. This mattered a lot in practice -
-                // NickServ/ChanServ almost universally reply to commands (IDENTIFY, etc.)
-                // via NOTICE rather than PRIVMSG, so without this fallback every identify
-                // success/failure notice was being filed under a buffer keyed by our OWN
-                // nick - which no window ever opens for - instead of under "NickServ",
-                // making it look like the automatic identify produced no feedback at all,
-                // whether or not it actually worked.
-                val bufferName = if (isChannelName(target)) target else (nick ?: target)
-                addMessage(BufferKey(serverId, bufferName), IrcMessage(now, MessageKind.NOTICE, nick, text))
-            }
             "NICK" -> {
                 val oldNick = nick ?: return
                 val newNick = line.params.getOrNull(0) ?: return
@@ -347,6 +471,7 @@ object ConnectionManager {
                 }
                 if (ownNicks[serverId] == oldNick) {
                     setOwnNick(serverId, newNick)
+                    addMainLine(MessageKind.NICK, null, "You are now known as $newNick")
                 }
             }
             "QUIT" -> {
@@ -360,6 +485,27 @@ object ConnectionManager {
                     }
                 }
             }
+            "INVITE" -> {
+                val channel = line.params.getOrNull(1) ?: return
+                addMainLine(MessageKind.SYSTEM, nick, "$nick invited you to $channel")
+            }
+            "ERROR" -> {
+                addMainLine(MessageKind.SYSTEM, null, "ERROR: ${line.params.joinToString(" ")}")
+            }
+            "PONG", "CAP" -> Unit
+            else -> {
+                when {
+                    line.command in WHOIS_NUMERICS -> handleWhoisLine(serverId, line)
+                    line.command in CHANNEL_ONLY_NUMERICS -> Unit
+                    // Every other numeric (welcome, ISUPPORT, LUSERS, MOTD, errors, ...) is a
+                    // server message; params[0] is just our own nick, so it's dropped.
+                    line.command.all { it.isDigit() } ->
+                        addMainLine(MessageKind.SYSTEM, line.prefix, line.params.drop(1).joinToString(" "))
+                    // Anything else not tied to a channel (WALLOPS, KILL, ...) - wIRC main as-is.
+                    else ->
+                        addMainLine(MessageKind.SYSTEM, nick, "${line.command} ${line.params.joinToString(" ")}".trim())
+                }
+            }
         }
     }
 }

src/main/kotlin/ui/ChannelScreen.kt

@@ -56,6 +56,7 @@ import androidx.compose.ui.window.WindowState
 import androidx.compose.ui.window.rememberDialogState
 import data.ChannelBuffer
 import data.ChannelUser
+import data.IrcMessage
 import data.MessageKind
 import data.WindowDisplaySettings
 import irc.extractImageUrls
@@ -287,15 +288,254 @@ fun WindowScope.ChannelScreen(
 
     val textColor = mircPalette[displaySettings.textColorMircIndex]
     val bgColor = Color.Black.copy(alpha = displaySettings.backgroundAlpha)
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .clickable(
+                indication = null,
+                interactionSource = remember { MutableInteractionSource() }
+            ) {
+                inputFocusRequester.requestFocus()
+            }
+            .background(bgColor)
+    ) {
+        Column(modifier = Modifier.fillMaxSize()) {
+            // Title bar: channel name + settings gear. Deliberately plain, no theming.
+            // undecorated windows have no native OS title bar, so this strip both displays
+            // the title and doubles as the drag handle to move the window (only this Row,
+            // not the whole window content, so it doesn't steal clicks from the rest of
+            // the UI) and hosts the minimize/close buttons the OS chrome would otherwise give.
+            // WindowDraggableArea is Compose Desktop's own drag-to-move implementation -
+            // a hand-rolled pointerInput/detectDragGestures version of this was jittery
+            // because manually accumulating dragAmount into windowState.position fights
+            // with the OS's own window-move handling; WindowDraggableArea talks to that
+            // directly instead of reimplementing it.
+            // The four buttons on the right fade in on hover (see FadingTitleBarButton); the
+            // channel name stays fully opaque.
+            WindowDraggableArea(modifier = Modifier.fillMaxWidth()) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 6.dp, vertical = 2.dp),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(channelName, color = textColor, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.labelSmall)
+                    Row {
+                        FadingTitleBarButton(onClick = { onShowUserListChange(!displaySettings.showUserList) }) {
+                            Icon(Icons.Default.Person, contentDescription = "Toggle user list", tint = textColor, modifier = Modifier.size(16.dp))
+                        }
+                        FadingTitleBarButton(onClick = { showSettings = !showSettings }) {
+                            Icon(Icons.Default.Settings, contentDescription = "Window settings", tint = textColor, modifier = Modifier.size(16.dp))
+                        }
+                        FadingTitleBarButton(onClick = { windowState.isMinimized = true }) {
+                            Box(
+                                modifier = Modifier
+                                    .size(width = 10.dp, height = 2.dp)
+                                    .background(textColor)
+                            )
+                        }
+                        FadingTitleBarButton(onClick = onCloseWindow) {
+                            Icon(Icons.Default.Close, contentDescription = "Close window", tint = textColor, modifier = Modifier.size(16.dp))
+                        }
+                    }
+                }
+            }
+
+            if (showSettings) {
+                // A real, separate top-level window (DialogWindow), not an AlertDialog/Popup
+                // embedded in this window's own layout. This used to be an inline Column
+                // squeezed directly into this Column below the title bar, sharing height with
+                // the message list and input bar - heightIn(max=280.dp) plus an internal
+                // scroll made every setting reachable once you'd already scrolled to it, but
+                // the panel (and the rest of this window's content fighting it for space) was
+                // still hard-clipped to whatever height this channel window itself currently
+                // had, e.g. a window resized shorter than ~280dp could clip the panel outright
+                // no matter how much its own content scrolled. A DialogWindow is a genuinely
+                // separate OS window sized on its own terms, so it can never be cut off by
+                // this channel window's current size. MaterialTheme/Surface are reapplied here
+                // because a DialogWindow is its own composition root - it doesn't inherit the
+                // MaterialTheme this window's own content sits under in ChannelWindow.kt.
+                DialogWindow(
+                    onCloseRequest = { showSettings = false },
+                    title = "$channelName settings",
+                    state = rememberDialogState(size = DpSize(340.dp, 560.dp)),
+                    resizable = true
+                ) {
+                    MaterialTheme(colorScheme = colorScheme) {
+                        Surface {
+                            WindowSettingsPanel(
+                                displaySettings = displaySettings,
+                                textColor = textColor,
+                                onAlphaChange = onAlphaChange,
+                                onTextColorChange = onTextColorChange,
+                                onFontSizeChange = onFontSizeChange,
+                                onNickColorsToggle = onNickColorsToggle,
+                                onMentionHighlightColorChange = onMentionHighlightColorChange,
+                                onShowImagePreviewsChange = onShowImagePreviewsChange
+                            )
+                        }
+                    }
+                }
+            }
+
+            // Scrollback + user list, side by side, filling the available height
+            Row(modifier = Modifier.weight(1f).fillMaxWidth()) {
+                MessageScrollback(
+                    messages = buffer?.messages ?: emptyList(),
+                    displaySettings = displaySettings,
+                    textColor = textColor,
+                    isMention = { isMention(it) },
+                    modifier = Modifier.weight(1f).fillMaxHeight()
+                )
+
+                // User list (tap and hold for OP actions)
+                if (displaySettings.showUserList && !buffer?.users.isNullOrEmpty()) {
+                    LazyColumn(
+                        modifier = Modifier
+                            .width(140.dp)
+                            .fillMaxHeight()
+                            .padding(4.dp)
+                    ) {
+                        items(buffer!!.users) { user ->
+                            Text(
+                                text = (if (user.isOp) "@" else if (user.isVoice) "+" else "") + user.nick,
+                                color = textColor,
+                                fontFamily = FontFamily.Monospace,
+                                fontSize = displaySettings.fontSize.sp,
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(vertical = 2.dp)
+                                    .combinedClickable(
+                                        onClick = {
+                                            val prefill = "/msg ${user.nick} "
+                                            input = TextFieldValue(prefill, androidx.compose.ui.text.TextRange(prefill.length))
+                                            inputFocusRequester.requestFocus()
+                                        },
+                                        onLongClick = { contextMenuUser = user }
+                                    )
+                            )
+                        }
+                    }
+                }
+            }
+
+            // Input bar
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(4.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Box(
+                    modifier = Modifier
+                        .weight(1f)
+                        .heightIn(min = 32.dp, max = 40.dp)
+                        .padding(vertical = 2.dp),
+                    contentAlignment = Alignment.CenterStart
+                ) {
+                BasicTextField(
+                    value = input,
+                    onValueChange = { input = it },
+                    singleLine = true,
+                    textStyle = androidx.compose.ui.text.TextStyle(
+                        fontFamily = FontFamily.Monospace,
+                        color = textColor,
+                        fontSize = displaySettings.fontSize.sp
+                    ),
+                    cursorBrush = SolidColor(textColor),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .focusRequester(inputFocusRequester)
+                        .onPreviewKeyEvent { event ->
+                            // Hardware-keyboard shortcuts: Ctrl+K color picker, Ctrl+B bold,
+                            // Ctrl+I italic, Ctrl+V paste (see pasteFromClipboardSafely -
+                            // intercepted and handled ourselves rather than left to
+                            // BasicTextField's own built-in paste, which hangs the whole
+                            // app if the native clipboard read blocks).
+                            if (event.type == KeyEventType.KeyDown && event.isCtrlPressed) {
+                                when (event.key) {
+                                    Key.K -> { showColorPicker = true; true }
+                                    Key.V -> { pasteFromClipboardSafely(); true }
+                                    Key.B -> { insertControlChar(''); true }
+                                    Key.I -> { insertControlChar(''); true }
+                                    else -> false
+                                }
+                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.Enter && !event.isCtrlPressed) {
+                                sendCurrentInput()
+                                true
+                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.Tab && !event.isCtrlPressed) {
+                                tryTabComplete()
+                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.DirectionUp) {
+                                if (history.isEmpty()) {
+                                    false
+                                } else {
+                                    if (historyIndex == -1) draftBeforeHistory = input.text
+                                    historyIndex = (historyIndex + 1).coerceAtMost(history.size - 1)
+                                    val entry = history[history.size - 1 - historyIndex]
+                                    input = TextFieldValue(entry, androidx.compose.ui.text.TextRange(entry.length))
+                                    true
+                                }
+                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.DirectionDown) {
+                                if (historyIndex == -1) {
+                                    false
+                                } else {
+                                    historyIndex--
+                                    if (historyIndex < 0) {
+                                        input = TextFieldValue(draftBeforeHistory, androidx.compose.ui.text.TextRange(draftBeforeHistory.length))
+                                    } else {
+                                        val entry = history[history.size - 1 - historyIndex]
+                                        input = TextFieldValue(entry, androidx.compose.ui.text.TextRange(entry.length))
+                                    }
+                                    true
+                                }
+                            } else false
+                        },
+                    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send),
+                    keyboardActions = KeyboardActions(onSend = { sendCurrentInput() })
+                )
+                }
+            }
+        }
+
+        contextMenuUser?.let { user ->
+            OpActionMenu(
+                user = user,
+                onDismiss = { contextMenuUser = null },
+                onKick = { onKick(user.nick); contextMenuUser = null },
+                onBan = { onBan(user.nick); contextMenuUser = null },
+                onOp = { onOp(user.nick); contextMenuUser = null },
+                onDeop = { onDeop(user.nick); contextMenuUser = null }
+            )
+        }
+
+        if (showColorPicker) {
+            MircColorPickerDialog(
+                onDismiss = { showColorPicker = false },
+                onPick = { fg, bg ->
+                    insertColorCode(fg, bg)
+                    showColorPicker = false
+                }
+            )
+        }
+    }
+}
+
+// Scrollback display shared by channel/PM windows (ChannelScreen) and wIRC main
+// (MainScreen): the message rows, image previews, line-height snapping and the
+// stick-to-bottom auto-scroll. Draws no background of its own - callers do.
+@Composable
+fun MessageScrollback(
+    messages: List<IrcMessage>,
+    displaySettings: WindowDisplaySettings,
+    textColor: Color,
+    isMention: (String) -> Boolean,
+    modifier: Modifier = Modifier
+) {
     val listState = rememberLazyListState()
     val timeFormat = remember { SimpleDateFormat("h:mm", Locale.getDefault()) }
 
-    // Single source of truth for "what messages exist" - used both by the scroll-tracking
-    // effects below and by the LazyColumn's items() call further down, so the two can never
-    // disagree about item count (they're reading the literal same list, not two separately
-    // re-derived ones).
-    val messages = buffer?.messages ?: emptyList()
-
     // Standard "stick to bottom unless the user scrolled up" chat-client pattern - the
     // ONLY code in this file that touches scroll position. A previous version of this had
     // several LaunchedEffects independently reading and writing listState/stickToBottom
@@ -390,108 +630,11 @@ fun WindowScope.ChannelScreen(
         }
     }
 
-    Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .clickable(
-                indication = null,
-                interactionSource = remember { MutableInteractionSource() }
-            ) {
-                inputFocusRequester.requestFocus()
-            }
-            .background(bgColor)
-    ) {
-        Column(modifier = Modifier.fillMaxSize()) {
-            // Title bar: channel name + settings gear. Deliberately plain, no theming.
-            // undecorated windows have no native OS title bar, so this strip both displays
-            // the title and doubles as the drag handle to move the window (only this Row,
-            // not the whole window content, so it doesn't steal clicks from the rest of
-            // the UI) and hosts the minimize/close buttons the OS chrome would otherwise give.
-            // WindowDraggableArea is Compose Desktop's own drag-to-move implementation -
-            // a hand-rolled pointerInput/detectDragGestures version of this was jittery
-            // because manually accumulating dragAmount into windowState.position fights
-            // with the OS's own window-move handling; WindowDraggableArea talks to that
-            // directly instead of reimplementing it.
-            // The four buttons on the right fade in on hover (see FadingTitleBarButton); the
-            // channel name stays fully opaque.
-            WindowDraggableArea(modifier = Modifier.fillMaxWidth()) {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 6.dp, vertical = 2.dp),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(channelName, color = textColor, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.labelSmall)
-                    Row {
-                        FadingTitleBarButton(onClick = { onShowUserListChange(!displaySettings.showUserList) }) {
-                            Icon(Icons.Default.Person, contentDescription = "Toggle user list", tint = textColor, modifier = Modifier.size(16.dp))
-                        }
-                        FadingTitleBarButton(onClick = { showSettings = !showSettings }) {
-                            Icon(Icons.Default.Settings, contentDescription = "Window settings", tint = textColor, modifier = Modifier.size(16.dp))
-                        }
-                        FadingTitleBarButton(onClick = { windowState.isMinimized = true }) {
-                            Box(
-                                modifier = Modifier
-                                    .size(width = 10.dp, height = 2.dp)
-                                    .background(textColor)
-                            )
-                        }
-                        FadingTitleBarButton(onClick = onCloseWindow) {
-                            Icon(Icons.Default.Close, contentDescription = "Close window", tint = textColor, modifier = Modifier.size(16.dp))
-                        }
-                    }
-                }
-            }
-
-            if (showSettings) {
-                // A real, separate top-level window (DialogWindow), not an AlertDialog/Popup
-                // embedded in this window's own layout. This used to be an inline Column
-                // squeezed directly into this Column below the title bar, sharing height with
-                // the message list and input bar - heightIn(max=280.dp) plus an internal
-                // scroll made every setting reachable once you'd already scrolled to it, but
-                // the panel (and the rest of this window's content fighting it for space) was
-                // still hard-clipped to whatever height this channel window itself currently
-                // had, e.g. a window resized shorter than ~280dp could clip the panel outright
-                // no matter how much its own content scrolled. A DialogWindow is a genuinely
-                // separate OS window sized on its own terms, so it can never be cut off by
-                // this channel window's current size. MaterialTheme/Surface are reapplied here
-                // because a DialogWindow is its own composition root - it doesn't inherit the
-                // MaterialTheme this window's own content sits under in ChannelWindow.kt.
-                DialogWindow(
-                    onCloseRequest = { showSettings = false },
-                    title = "$channelName settings",
-                    state = rememberDialogState(size = DpSize(340.dp, 560.dp)),
-                    resizable = true
-                ) {
-                    MaterialTheme(colorScheme = colorScheme) {
-                        Surface {
-                            WindowSettingsPanel(
-                                displaySettings = displaySettings,
-                                textColor = textColor,
-                                onAlphaChange = onAlphaChange,
-                                onTextColorChange = onTextColorChange,
-                                onFontSizeChange = onFontSizeChange,
-                                onNickColorsToggle = onNickColorsToggle,
-                                onMentionHighlightColorChange = onMentionHighlightColorChange,
-                                onShowImagePreviewsChange = onShowImagePreviewsChange
-                            )
-                        }
-                    }
-                }
-            }
-
-            // Scrollback + user list, side by side, filling the available height
-            Row(modifier = Modifier.weight(1f).fillMaxWidth()) {
     // Scrollback height is snapped down to a whole multiple of one line's height so a
     // resize never leaves a partially-rendered line visible - the leftover fractional
     // space is absorbed by the Spacer below instead, leaving the rest of the layout
     // (nicklist, input bar) unaffected.
-                BoxWithConstraints(
-                    modifier = Modifier
-                        .weight(1f)
-                        .fillMaxHeight()
-                ) {
+    BoxWithConstraints(modifier = modifier) {
         // Investigated (see task: resized-window slowdown) whether this was
         // re-measuring text or producing an unstable snappedHeight on every
         // recomposition instead of only on a genuine font-size/window-size
@@ -671,137 +814,6 @@ fun WindowScope.ChannelScreen(
     Spacer(modifier = Modifier.weight(1f))
     }
     }
-
-                // User list (tap and hold for OP actions)
-                if (displaySettings.showUserList && !buffer?.users.isNullOrEmpty()) {
-                    LazyColumn(
-                        modifier = Modifier
-                            .width(140.dp)
-                            .fillMaxHeight()
-                            .padding(4.dp)
-                    ) {
-                        items(buffer!!.users) { user ->
-                            Text(
-                                text = (if (user.isOp) "@" else if (user.isVoice) "+" else "") + user.nick,
-                                color = textColor,
-                                fontFamily = FontFamily.Monospace,
-                                fontSize = displaySettings.fontSize.sp,
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .padding(vertical = 2.dp)
-                                    .combinedClickable(
-                                        onClick = {
-                                            val prefill = "/msg ${user.nick} "
-                                            input = TextFieldValue(prefill, androidx.compose.ui.text.TextRange(prefill.length))
-                                            inputFocusRequester.requestFocus()
-                                        },
-                                        onLongClick = { contextMenuUser = user }
-                                    )
-                            )
-                        }
-                    }
-                }
-            }
-
-            // Input bar
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(4.dp),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Box(
-                    modifier = Modifier
-                        .weight(1f)
-                        .heightIn(min = 32.dp, max = 40.dp)
-                        .padding(vertical = 2.dp),
-                    contentAlignment = Alignment.CenterStart
-                ) {
-                BasicTextField(
-                    value = input,
-                    onValueChange = { input = it },
-                    singleLine = true,
-                    textStyle = androidx.compose.ui.text.TextStyle(
-                        fontFamily = FontFamily.Monospace,
-                        color = textColor,
-                        fontSize = displaySettings.fontSize.sp
-                    ),
-                    cursorBrush = SolidColor(textColor),
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .focusRequester(inputFocusRequester)
-                        .onPreviewKeyEvent { event ->
-                            // Hardware-keyboard shortcuts: Ctrl+K color picker, Ctrl+B bold,
-                            // Ctrl+I italic, Ctrl+V paste (see pasteFromClipboardSafely -
-                            // intercepted and handled ourselves rather than left to
-                            // BasicTextField's own built-in paste, which hangs the whole
-                            // app if the native clipboard read blocks).
-                            if (event.type == KeyEventType.KeyDown && event.isCtrlPressed) {
-                                when (event.key) {
-                                    Key.K -> { showColorPicker = true; true }
-                                    Key.V -> { pasteFromClipboardSafely(); true }
-                                    Key.B -> { insertControlChar(''); true }
-                                    Key.I -> { insertControlChar(''); true }
-                                    else -> false
-                                }
-                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.Enter && !event.isCtrlPressed) {
-                                sendCurrentInput()
-                                true
-                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.Tab && !event.isCtrlPressed) {
-                                tryTabComplete()
-                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.DirectionUp) {
-                                if (history.isEmpty()) {
-                                    false
-                                } else {
-                                    if (historyIndex == -1) draftBeforeHistory = input.text
-                                    historyIndex = (historyIndex + 1).coerceAtMost(history.size - 1)
-                                    val entry = history[history.size - 1 - historyIndex]
-                                    input = TextFieldValue(entry, androidx.compose.ui.text.TextRange(entry.length))
-                                    true
-                                }
-                            } else if (event.type == KeyEventType.KeyDown && event.key == Key.DirectionDown) {
-                                if (historyIndex == -1) {
-                                    false
-                                } else {
-                                    historyIndex--
-                                    if (historyIndex < 0) {
-                                        input = TextFieldValue(draftBeforeHistory, androidx.compose.ui.text.TextRange(draftBeforeHistory.length))
-                                    } else {
-                                        val entry = history[history.size - 1 - historyIndex]
-                                        input = TextFieldValue(entry, androidx.compose.ui.text.TextRange(entry.length))
-                                    }
-                                    true
-                                }
-                            } else false
-                        },
-                    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send),
-                    keyboardActions = KeyboardActions(onSend = { sendCurrentInput() })
-                )
-                }
-            }
-        }
-
-        contextMenuUser?.let { user ->
-            OpActionMenu(
-                user = user,
-                onDismiss = { contextMenuUser = null },
-                onKick = { onKick(user.nick); contextMenuUser = null },
-                onBan = { onBan(user.nick); contextMenuUser = null },
-                onOp = { onOp(user.nick); contextMenuUser = null },
-                onDeop = { onDeop(user.nick); contextMenuUser = null }
-            )
-        }
-
-        if (showColorPicker) {
-            MircColorPickerDialog(
-                onDismiss = { showColorPicker = false },
-                onPick = { fg, bg ->
-                    insertColorCode(fg, bg)
-                    showColorPicker = false
-                }
-            )
-        }
-    }
 }
 
 // A 28dp title-bar IconButton that rests invisible and fades in while hovered. The fade

src/main/kotlin/ui/ChannelWindow.kt

@@ -10,8 +10,9 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Window
-import androidx.compose.ui.window.rememberWindowState
 import data.AliasRepository
 import data.BufferKey
 import data.WindowDisplaySettings
@@ -59,7 +60,9 @@ fun ChannelWindow(
     val buffer by remember(bufferKey) { derivedStateOf { buffers[bufferKey] } }
     val ownNicks by ConnectionManager.ownNicksFlow.collectAsState()
     val ownNick by remember(serverId) { derivedStateOf { ownNicks[serverId] } }
-    val windowState = rememberWindowState()
+    // Restored from window_prefs.json (or cascaded if there's no usable saved position)
+    // and saved back on move/resize/close - see WindowPlacement.kt.
+    val windowState = rememberPersistentWindowState(prefsRepo, bufferKey.storageId(), DpSize(800.dp, 600.dp))
 
     // undecorated + transparent trade the native OS title bar for real per-pixel window
     // transparency (Windows only honors transparency on undecorated windows) - ChannelScreen
@@ -124,6 +127,9 @@ fun ChannelWindow(
                                         ConnectionManager.sendRaw(serverId, "JOIN $args")
                                         onOpenBuffer(BufferKey(serverId, args))
                                     }
+                                    // Reply lines come back to this window, or to wIRC main if
+                                    // this window is closed before they arrive.
+                                    "WHOIS" -> ConnectionManager.whois(serverId, args, origin = bufferKey)
                                     "MSG" -> {
                                         val msgSpaceIdx = args.indexOf(' ')
                                         if (msgSpaceIdx >= 0) {

src/main/kotlin/ui/MainScreen.kt

@@ -1,5 +1,7 @@
 package ui
 
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
@@ -11,7 +13,9 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusDirection
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.LocalWindowInfo
 import androidx.compose.ui.input.key.Key
 import androidx.compose.ui.input.key.KeyEventType
 import androidx.compose.ui.input.key.isShiftPressed
@@ -23,9 +27,12 @@ import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.DialogWindow
 import androidx.compose.ui.window.rememberDialogState
+import data.MAIN_BUFFER_KEY
 import data.ServerConfig
 import data.ServerRepository
+import data.WindowDisplaySettings
 import irc.ConnectionManager
+import irc.mircPalette
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
@@ -33,8 +40,10 @@ import kotlinx.coroutines.launch
 fun MainScreen(
     repo: ServerRepository,
     colorScheme: ColorScheme,
+    displaySettings: WindowDisplaySettings,
     onOpenChannel: (serverId: String, channelName: String) -> Unit,
-    onExitApp: () -> Unit
+    onExitApp: () -> Unit,
+    onUnreadChange: (Int) -> Unit
 ) {
     var servers by remember { mutableStateOf(repo.loadAll()) }
     var showAddDialog by remember { mutableStateOf(false) }
@@ -44,6 +53,26 @@ fun MainScreen(
     var openedChannels by remember { mutableStateOf(mapOf<String, List<String>>()) }
     val coroutineScope = rememberCoroutineScope()
 
+    val buffers by ConnectionManager.buffers.collectAsState()
+    val mainMessages by remember { derivedStateOf { buffers[MAIN_BUFFER_KEY]?.messages ?: emptyList() } }
+    val textColor = mircPalette[displaySettings.textColorMircIndex]
+
+    // Unread indicator: lines that arrived in wIRC main while this window didn't have focus
+    // (e.g. while typing in a channel window). Shown next to the "Server messages" label and,
+    // via onUnreadChange, in the window title / taskbar. Cleared as soon as the window is
+    // focused. Compared by timestamp rather than count so history loaded at startup never
+    // counts as new.
+    val windowFocused = LocalWindowInfo.current.isWindowFocused
+    var lastSeenMillis by remember { mutableStateOf(System.currentTimeMillis()) }
+    val newest = mainMessages.lastOrNull()
+    LaunchedEffect(windowFocused, newest?.seq) {
+        if (windowFocused) {
+            lastSeenMillis = maxOf(lastSeenMillis, newest?.timestampMillis ?: 0L, System.currentTimeMillis())
+        }
+    }
+    val unread = if (windowFocused) 0 else mainMessages.count { it.timestampMillis > lastSeenMillis }
+    LaunchedEffect(unread) { onUnreadChange(unread) }
+
     Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
         Row(
             modifier = Modifier.fillMaxWidth(),
@@ -125,6 +154,34 @@ fun MainScreen(
                 Spacer(Modifier.height(12.dp))
             }
         }
+
+        Spacer(Modifier.height(8.dp))
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Text("Server messages", style = MaterialTheme.typography.labelMedium)
+            if (unread > 0) {
+                Spacer(Modifier.width(8.dp))
+                Text(
+                    "\u25CF $unread new",
+                    color = UNREAD_INDICATOR_COLOR,
+                    style = MaterialTheme.typography.labelMedium
+                )
+            }
+        }
+        Spacer(Modifier.height(4.dp))
+        // MOTD, numerics, errors, services/server notices and WHOIS replies whose window
+        // is gone - see ConnectionManager. Same rendering and auto-scroll as a channel window.
+        MessageScrollback(
+            messages = mainMessages,
+            displaySettings = displaySettings,
+            textColor = textColor,
+            isMention = { false },
+            modifier = Modifier
+                .weight(1f)
+                .fillMaxWidth()
+                .background(Color.Black.copy(alpha = displaySettings.backgroundAlpha))
+                .border(1.dp, Color.Gray.copy(alpha = 0.5f))
+                .padding(vertical = 2.dp)
+        )
     }
 
     if (showAddDialog) {
@@ -141,6 +198,8 @@ fun MainScreen(
     }
 }
 
+private val UNREAD_INDICATOR_COLOR = Color(0xFFFFA500)
+
 @Composable
 private fun ServerCard(
     server: ServerConfig,

src/main/kotlin/ui/WindowPlacement.kt

@@ -0,0 +1,158 @@
+package ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.isSpecified
+import androidx.compose.ui.window.WindowPlacement
+import androidx.compose.ui.window.WindowPosition
+import androidx.compose.ui.window.WindowState
+import androidx.compose.ui.window.rememberWindowState
+import data.WindowBounds
+import data.WindowPrefsRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.withContext
+import java.awt.GraphicsEnvironment
+import java.awt.Rectangle
+import java.awt.Toolkit
+
+// How long a window has to sit still after a move/resize before its bounds are written
+// to window_prefs.json - dragging fires a position change per mouse event.
+private const val BOUNDS_SAVE_DEBOUNCE_MS = 500L
+
+// Cascade layout for windows with no usable saved position: the first one opens
+// CASCADE_MARGIN_DP in from the top-left of the primary screen's usable area (taskbar
+// excluded), each next one CASCADE_STEP_DP further down and right, wrapping back to the
+// start before a window would run off the screen.
+private const val CASCADE_MARGIN_DP = 40
+private const val CASCADE_STEP_DP = 32
+
+// A saved position only counts as "on a connected monitor" if at least this much of the
+// window's top strip (where the drag handle / title bar is) lands on one screen, so a
+// restored window can always be grabbed and moved.
+private const val TITLE_STRIP_HEIGHT_DP = 32
+private const val MIN_VISIBLE_TITLE_WIDTH_DP = 80
+
+// Saved sizes smaller than this are treated as invalid and replaced by the default.
+private const val MIN_WINDOW_WIDTH_DP = 200
+private const val MIN_WINDOW_HEIGHT_DP = 120
+
+private object WindowCascade {
+    private var next = 0
+
+    @Synchronized
+    fun nextPosition(size: DpSize): WindowPosition {
+        val area = primaryUsableArea()
+        val roomX = area.width - CASCADE_MARGIN_DP - size.width.value
+        val roomY = area.height - CASCADE_MARGIN_DP - size.height.value
+        val stepsThatFit = (minOf(roomX, roomY) / CASCADE_STEP_DP).toInt().coerceAtLeast(0)
+        val step = next++ % (stepsThatFit + 1)
+        val offset = CASCADE_MARGIN_DP + step * CASCADE_STEP_DP
+        return WindowPosition.Absolute((area.x + offset).dp, (area.y + offset).dp)
+    }
+}
+
+private fun primaryUsableArea(): Rectangle = try {
+    val config = GraphicsEnvironment.getLocalGraphicsEnvironment().defaultScreenDevice.defaultConfiguration
+    val bounds = config.bounds
+    val insets = Toolkit.getDefaultToolkit().getScreenInsets(config)
+    Rectangle(
+        bounds.x + insets.left,
+        bounds.y + insets.top,
+        bounds.width - insets.left - insets.right,
+        bounds.height - insets.top - insets.bottom
+    )
+} catch (e: Exception) {
+    Rectangle(0, 0, 1280, 720)
+}
+
+private fun screenBounds(): List<Rectangle> = try {
+    GraphicsEnvironment.getLocalGraphicsEnvironment().screenDevices.map { it.defaultConfiguration.bounds }
+} catch (e: Exception) {
+    emptyList()
+}
+
+private fun isOnConnectedScreen(x: Float, y: Float, width: Float): Boolean {
+    val strip = Rectangle(x.toInt(), y.toInt(), width.toInt().coerceAtLeast(1), TITLE_STRIP_HEIGHT_DP)
+    val minVisibleWidth = minOf(MIN_VISIBLE_TITLE_WIDTH_DP, strip.width)
+    return screenBounds().any { screen ->
+        val visible = screen.intersection(strip)
+        !visible.isEmpty && visible.width >= minVisibleWidth && visible.height >= TITLE_STRIP_HEIGHT_DP / 2
+    }
+}
+
+private fun resolveInitialPlacement(saved: WindowBounds?, defaultSize: DpSize): Pair<WindowPosition, DpSize> {
+    val savedWidth = saved?.width
+    val savedHeight = saved?.height
+    val size = if (savedWidth != null && savedHeight != null &&
+        savedWidth >= MIN_WINDOW_WIDTH_DP && savedHeight >= MIN_WINDOW_HEIGHT_DP
+    ) {
+        // Never restore a window bigger than the largest connected screen (e.g. it was
+        // saved on a monitor that has since been unplugged).
+        val screens = screenBounds()
+        val maxWidth = screens.maxOfOrNull { it.width }?.toFloat() ?: savedWidth
+        val maxHeight = screens.maxOfOrNull { it.height }?.toFloat() ?: savedHeight
+        DpSize(minOf(savedWidth, maxWidth).dp, minOf(savedHeight, maxHeight).dp)
+    } else {
+        defaultSize
+    }
+
+    val savedX = saved?.x
+    val savedY = saved?.y
+    val position = if (savedX != null && savedY != null && isOnConnectedScreen(savedX, savedY, size.width.value)) {
+        WindowPosition.Absolute(savedX.dp, savedY.dp)
+    } else {
+        WindowCascade.nextPosition(size)
+    }
+    return position to size
+}
+
+private fun saveBoundsIfFloating(state: WindowState, prefsRepo: WindowPrefsRepository, storageId: String) {
+    // Minimized windows report a parking position far off-screen on Windows, and a
+    // maximized/fullscreen window's bounds are the screen's - neither is a position the
+    // user chose, so only plain floating bounds are remembered.
+    if (state.isMinimized || state.placement != WindowPlacement.Floating) return
+    val position = state.position
+    val size = state.size
+    if (position !is WindowPosition.Absolute || !size.isSpecified) return
+    prefsRepo.setWindowBounds(
+        storageId,
+        WindowBounds(position.x.value, position.y.value, size.width.value, size.height.value)
+    )
+}
+
+/**
+ * A WindowState that starts at the window's saved position and size from window_prefs.json
+ * (if that position is still on a connected monitor), otherwise at the next cascade slot,
+ * and writes its bounds back whenever the window is moved or resized and when it closes.
+ */
+@Composable
+fun rememberPersistentWindowState(
+    prefsRepo: WindowPrefsRepository,
+    storageId: String,
+    defaultSize: DpSize
+): WindowState {
+    val (initialPosition, initialSize) = remember(storageId) {
+        resolveInitialPlacement(prefsRepo.boundsFor(storageId), defaultSize)
+    }
+    val state = rememberWindowState(position = initialPosition, size = initialSize)
+
+    LaunchedEffect(state, storageId) {
+        snapshotFlow { listOf(state.position, state.size, state.placement, state.isMinimized) }
+            .collectLatest {
+                delay(BOUNDS_SAVE_DEBOUNCE_MS)
+                withContext(Dispatchers.IO) { saveBoundsIfFloating(state, prefsRepo, storageId) }
+            }
+    }
+    // Catches a move/resize made less than BOUNDS_SAVE_DEBOUNCE_MS before the window closed.
+    DisposableEffect(state, storageId) {
+        onDispose { saveBoundsIfFloating(state, prefsRepo, storageId) }
+    }
+    return state
+}