fix: crash on send (main-thread DB), dedup connections, bouncer nick field

- CRASH: EventProcessor.findSelfEchoCandidate ran a synchronous db.query on
  the main thread (events collector runs on Main) -> IllegalStateException on
  every send. Replaced with a suspend @query DAO method (off-main + safe
  inside the HistoryBatch transaction).
- dedup: NetworkRepository.addNetwork returns an existing equivalent network
  instead of inserting a duplicate (role-aware key), preventing duplicate
  server connections; NetworkDao.allNow.
- bouncer form restores the nick field (host/port/tls/nick/username/password);
  buildNetworkEntity uses the real nick. (SASL PLAIN NUL separators verified
  correct — no :irc change.)

Author: trevarj

app/src/main/kotlin/io/github/trevarj/motd/data/db/Daos.kt

@@ -38,6 +38,13 @@ interface NetworkDao {
 
     @Query("SELECT * FROM networks WHERE parentId = :rootId")
     suspend fun childrenOf(rootId: Long): List<NetworkEntity>
+
+    // Snapshot of all rows for the app-level duplicate check in NetworkRepositoryImpl.addNetwork.
+    // A one-shot read (not the observed Flow) so dedup is a simple suspend call; the networks
+    // table is tiny (a handful of rows) so a full scan is cheap and avoids a per-identity index
+    // that would need a schema bump (DB is v1, no migrations).
+    @Query("SELECT * FROM networks")
+    suspend fun allNow(): List<NetworkEntity>
 }
 
 @Dao
@@ -155,6 +162,19 @@ interface MessageDao {
     @Query("SELECT * FROM messages WHERE bufferId = :bufferId AND msgid = :msgid LIMIT 1")
     suspend fun byMsgid(bufferId: Long, msgid: String): MessageEntity?
 
+    /**
+     * Newest local self row for [bufferId] matching [text] within [lo]..[hi] serverTime, to collapse
+     * an un-labeled echo into a pending/confirmed-local row (plans/03 echo heuristic). Un-confirmed
+     * (pendingLabel set) rows rank first. A suspend @Query runs off the main thread and is
+     * transaction-safe (both the live onChat path and the HistoryBatch withTransaction path).
+     */
+    @Query(
+        """SELECT * FROM messages WHERE bufferId = :bufferId AND isSelf = 1 AND text = :text
+          AND serverTime BETWEEN :lo AND :hi
+          ORDER BY (pendingLabel IS NOT NULL) DESC, serverTime DESC, id DESC LIMIT 1"""
+    )
+    suspend fun findSelfEchoCandidate(bufferId: Long, text: String, lo: Long, hi: Long): MessageEntity?
+
     // Delete a single row by primary key. Used to drop a failed local-echo row on retry/delete so
     // the resend does not leave a permanent duplicate "failed" bubble (plans/15 #10).
     @Query("DELETE FROM messages WHERE id = :id")

app/src/main/kotlin/io/github/trevarj/motd/data/repo/NetworkRepositoryImpl.kt

@@ -2,17 +2,31 @@ package io.github.trevarj.motd.data.repo
 
 import io.github.trevarj.motd.data.db.NetworkDao
 import io.github.trevarj.motd.data.db.NetworkEntity
+import io.github.trevarj.motd.data.db.NetworkRole
 import javax.inject.Inject
 import kotlinx.coroutines.flow.Flow
 
 // Thin pass-through over NetworkDao. Delete resolves the row by id first (Dao.delete takes an
-// entity); a missing row is a no-op.
+// entity); a missing row is a no-op. addNetwork additionally dedups against existing rows so
+// re-running onboarding / "Add network" for a server the user already has does not create a
+// duplicate NetworkEntity (which would spawn a second actor + socket for the same server).
 class NetworkRepositoryImpl @Inject constructor(
     private val networkDao: NetworkDao,
 ) : NetworkRepository {
     override fun observeNetworks(): Flow<List<NetworkEntity>> = networkDao.observeAll()
 
-    override suspend fun addNetwork(n: NetworkEntity): Long = networkDao.insert(n)
+    /**
+     * Insert [n], or return the id of an existing equivalent network instead of creating a
+     * duplicate. Two rows are "the same server" when [networkIdentityKey] matches (see there for
+     * the per-role key). The dedup is at the data layer so every add path (onboarding, Add
+     * network, soju child import) is covered transparently and callers keep the "returns the row
+     * id" contract — they just get the pre-existing id on a duplicate.
+     */
+    override suspend fun addNetwork(n: NetworkEntity): Long {
+        val key = networkIdentityKey(n)
+        networkDao.allNow().firstOrNull { networkIdentityKey(it) == key }?.let { return it.id }
+        return networkDao.insert(n)
+    }
 
     override suspend fun updateNetwork(n: NetworkEntity) = networkDao.update(n)
 
@@ -24,3 +38,31 @@ class NetworkRepositoryImpl @Inject constructor(
 
     override suspend fun childrenOf(rootId: Long): List<NetworkEntity> = networkDao.childrenOf(rootId)
 }
+
+/** Normalize a host for identity comparison: trim, drop a trailing dot, lowercase (DNS is
+ *  case-insensitive). Hostnames are ASCII so [lowercase] with the default locale is safe. */
+internal fun normalizeHost(host: String): String =
+    host.trim().trimEnd('.').lowercase()
+
+/**
+ * Stable identity key deciding whether two [NetworkEntity] rows are the same server, used by
+ * [NetworkRepositoryImpl.addNetwork] to reject duplicates. Keyed per role:
+ *
+ * - **BOUNCER_CHILD**: `(parentId, bouncerNetId)` — a child is one bouncer-side network under one
+ *   root, regardless of host (the mirror may not know the host yet). Guards both the onboarding
+ *   import loop and the notify-mirror racing to insert the same child.
+ * - **BOUNCER_ROOT**: `(host, port, saslUser)` — one soju account (login) per host:port. Adding
+ *   the same bouncer account twice reuses the existing root.
+ * - **DIRECT**: `(host, port, nick)` — the same server with the same nick is the same connection;
+ *   a different nick is intentionally a distinct network (two identities on one server).
+ *
+ * A `null` sub-key element is kept distinct (encoded as an empty segment) so under-specified rows
+ * don't collapse onto each other.
+ */
+internal fun networkIdentityKey(n: NetworkEntity): String = when (n.role) {
+    NetworkRole.BOUNCER_CHILD -> "child|${n.parentId}|${n.bouncerNetId.orEmpty()}"
+    NetworkRole.BOUNCER_ROOT ->
+        "root|${normalizeHost(n.host)}|${n.port}|${n.saslUser.orEmpty()}"
+    NetworkRole.DIRECT ->
+        "direct|${normalizeHost(n.host)}|${n.port}|${n.nick}"
+}

app/src/main/kotlin/io/github/trevarj/motd/data/sync/EventProcessor.kt

@@ -515,40 +515,16 @@ class EventProcessor @Inject constructor(
      * strongest match); a confirmed-local row (from the no-labeled-response send path) also matches
      * so its self-clock dedupKey collapses with the server echo. Returns null when nothing matches.
      */
-    private suspend fun findSelfEchoCandidate(bufferId: Long, text: String, echoTime: Long): MessageEntity? {
-        // Run synchronously on the calling coroutine (no Dispatchers.IO switch): this can execute
-        // inside a Room withTransaction (HistoryBatch), where hopping threads violates Room's
-        // transaction confinement and throws. db.query() is a plain blocking cursor read.
-        val lo = echoTime - ECHO_MATCH_WINDOW_MS
-        val hi = echoTime + ECHO_MATCH_WINDOW_MS
-        val q = androidx.sqlite.db.SimpleSQLiteQuery(
-            "SELECT * FROM messages WHERE bufferId = ? AND isSelf = 1 AND text = ? " +
-                "AND serverTime BETWEEN ? AND ? " +
-                // Un-confirmed rows first (pendingLabel set), then newest.
-                "ORDER BY (pendingLabel IS NOT NULL) DESC, serverTime DESC, id DESC LIMIT 1",
-            arrayOf<Any>(bufferId, text, lo, hi),
+    private suspend fun findSelfEchoCandidate(bufferId: Long, text: String, echoTime: Long): MessageEntity? =
+        // Delegates to a suspend @Query: Room runs it off the main thread (the events collector runs
+        // on Dispatchers.Main) and handles it correctly inside the HistoryBatch withTransaction too —
+        // the previous raw db.query() ran synchronously on the caller's thread and crashed on send.
+        messageDao.findSelfEchoCandidate(
+            bufferId,
+            text,
+            echoTime - ECHO_MATCH_WINDOW_MS,
+            echoTime + ECHO_MATCH_WINDOW_MS,
         )
-        return db.query(q).use { c ->
-            if (!c.moveToFirst()) return@use null
-            fun col(name: String) = c.getColumnIndexOrThrow(name)
-            MessageEntity(
-                id = c.getLong(col("id")),
-                bufferId = c.getLong(col("bufferId")),
-                msgid = c.getString(col("msgid")),
-                serverTime = c.getLong(col("serverTime")),
-                sender = c.getString(col("sender")),
-                senderAccount = c.getString(col("senderAccount")),
-                kind = MessageKind.valueOf(c.getString(col("kind"))),
-                text = c.getString(col("text")),
-                isSelf = c.getInt(col("isSelf")) != 0,
-                hasMention = c.getInt(col("hasMention")) != 0,
-                replyToMsgid = c.getString(col("replyToMsgid")),
-                pendingLabel = c.getString(col("pendingLabel")),
-                failed = c.getInt(col("failed")) != 0,
-                dedupKey = c.getString(col("dedupKey")),
-            )
-        }
-    }
 
     /** Buffer ids where [nick] is currently a member on [networkId] (for quit/nick fan-out). */
     private suspend fun buffersOfNick(networkId: Long, nick: String): List<Long> =

app/src/main/kotlin/io/github/trevarj/motd/ui/onboarding/OnboardingReducer.kt

@@ -55,14 +55,15 @@ data class ServerForm(
     )
 
     /**
-     * Minimal validity for enabling "next" on the direct-network SERVER step: host, valid port,
-     * and a nick. The soju path validates against [isValidForSoju] (no nick collected there).
+     * SERVER-step validity for both paths: host, a valid port, and a nick. The soju root now
+     * collects a nick too (it is the IRC NICK the bouncer registers with); its bouncer SASL
+     * username/password are gathered on the AUTH step.
      */
     val isValid: Boolean
-        get() = isValidForSoju && nick.isNotBlank()
+        get() = hostAndPortValid && nick.isNotBlank()
 
-    /** soju SERVER step needs only host + a valid port (identity comes from SASL). */
-    val isValidForSoju: Boolean
+    /** Transport-only validity (host + valid port), independent of identity. */
+    val hostAndPortValid: Boolean
         get() = host.isNotBlank() &&
             port.toIntOrNull()?.let { it in 1..65535 } == true
 }
@@ -117,8 +118,8 @@ data class OnboardingState(
         get() = when (step) {
             OnboardingStep.WELCOME -> true
             OnboardingStep.CHOICE -> choice != null
-            // soju collects only host/port on SERVER (identity is SASL); direct also needs a nick.
-            OnboardingStep.SERVER -> if (isSoju) server.isValidForSoju else server.isValid
+            // Both paths collect host/port/nick on SERVER; soju's SASL user/password gate AUTH.
+            OnboardingStep.SERVER -> server.isValid
             OnboardingStep.AUTH -> auth.isValid
             OnboardingStep.CONNECT -> isReady
             OnboardingStep.FINISH -> true

app/src/main/kotlin/io/github/trevarj/motd/ui/onboarding/OnboardingScreen.kt

@@ -285,8 +285,10 @@ private fun ServerPage(
             onAuthChange = onAuthChange,
             showServer = !authOnly,
             showAuth = authOnly,
-            // soju SERVER step: host/port/TLS only; identity is managed by the bouncer via SASL.
+            // Direct path shows the full identity (nick/username/realname); the soju root shows
+            // only the nick here (its bouncer SASL user/password live on the AUTH step).
             showIdentity = !state.isSoju,
+            showNick = state.isSoju,
         )
     }
 }

app/src/main/kotlin/io/github/trevarj/motd/ui/settings/NetworkForm.kt

@@ -47,16 +47,23 @@ fun NetworkForm(
     modifier: Modifier = Modifier,
     showServer: Boolean = true,
     showAuth: Boolean = true,
-    // soju bouncer: identity (nick/username/realname) is managed per-network by soju via SASL,
-    // so the root form collects only host/port/TLS and hides the identity fields.
+    // Full USER-ident identity (nick + username + realname): the direct-network path shows all
+    // three. The soju root shows only [showNick] (its nick), since the bouncer SASL user/password
+    // live on the AUTH step and username/realname default to the nick.
     showIdentity: Boolean = true,
+    showNick: Boolean = false,
 ) {
     Column(
         modifier = modifier.fillMaxWidth().padding(horizontal = 16.dp),
         verticalArrangement = Arrangement.spacedBy(12.dp),
     ) {
         if (showServer) {
-            ServerFields(server = server, onServerChange = onServerChange, showIdentity = showIdentity)
+            ServerFields(
+                server = server,
+                onServerChange = onServerChange,
+                showIdentity = showIdentity,
+                showNick = showNick,
+            )
         }
         if (showAuth) {
             Text(
@@ -71,14 +78,16 @@ fun NetworkForm(
 }
 
 /**
- * Server fields. [showIdentity] gates nick/username/realname: soju manages those per bound
- * network via SASL, so its root form shows only host/port/TLS.
+ * Server fields. [showIdentity] gates the full nick/username/realname block (direct networks);
+ * [showNick] surfaces just the nick (soju root), whose username/realname default to the nick and
+ * whose SASL login lives on the AUTH step.
  */
 @Composable
 private fun ServerFields(
     server: ServerForm,
     onServerChange: (ServerForm) -> Unit,
     showIdentity: Boolean = true,
+    showNick: Boolean = false,
 ) {
     OutlinedTextField(
         value = server.host,
@@ -103,14 +112,17 @@ private fun ServerFields(
         // withTls re-defaults the port (6697<->6667) unless the user typed a custom one.
         Switch(checked = server.tls, onCheckedChange = { onServerChange(server.withTls(it)) })
     }
-    if (showIdentity) {
+    // Nick is shown for the full-identity direct path and for the nick-only soju root.
+    if (showIdentity || showNick) {
         OutlinedTextField(
             value = server.nick,
             onValueChange = { onServerChange(server.copy(nick = it)) },
             label = { Text(stringResource(R.string.onboarding_field_nick)) },
             singleLine = true,
             modifier = Modifier.fillMaxWidth(),
         )
+    }
+    if (showIdentity) {
         OutlinedTextField(
             value = server.username,
             onValueChange = { onServerChange(server.copy(username = it)) },
@@ -220,9 +232,10 @@ fun buildNetworkEntity(
     parentId: Long? = null,
     bouncerNetId: String? = null,
 ): NetworkEntity {
-    // soju manages per-network identity itself; its root form collects no nick/username/realname,
-    // but :irc still sends USER/NICK on the root socket, so seed them from the SASL login username
-    // (falling back to a placeholder) to keep the registration lines well-formed.
+    // :irc sends NICK/USER on every socket (incl. the soju root). The nick is now collected on
+    // both paths, so prefer it; fall back to the SASL login user, then a placeholder, only as a
+    // last resort to keep the registration lines well-formed. username/realname default to the
+    // nick when not surfaced.
     val identitySeed = server.nick.ifBlank { auth.saslUser.ifBlank { DEFAULT_IDENTITY } }
     return NetworkEntity(
         id = id,