fix(chat): chat-screen core correctness + states (plans/15 C)

- guard deep-jump against empty list; robust APPEND wait; reliable
  not-found snackbar; once-guarded re-resolve
- mark-read only on resume/at-bottom with a frozen read-marker snapshot,
  restoring the unread divider and FAB badge
- LazyColumn item keys (no scroll jumps); reactions aggregated in the VM
  by buffer (no SQL IN-clause overflow, no blank-frame churn)
- loadState footer (loading/error/beginning) + empty-buffer state; imePadding
- retry removes the failed row and re-sends (ACTION preserved) + delete;
  collapse JOIN/PART/QUIT runs into one pill; pending 'sending' indicator
- member-count plural, localized typing subtitle + day separators

Author: trevarj

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

@@ -135,6 +135,11 @@ interface MessageDao {
     @Query("SELECT * FROM messages WHERE bufferId = :bufferId AND msgid = :msgid LIMIT 1")
     suspend fun byMsgid(bufferId: Long, msgid: String): 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")
+    suspend fun deleteById(id: Long)
+
     /** 0-based reverse-list index: strict complement of pagingSource ORDER BY serverTime DESC, id DESC. */
     @Query(
         """SELECT COUNT(*) FROM messages WHERE bufferId = :bufferId
@@ -192,6 +197,13 @@ interface ReactionDao {
     @Query("SELECT * FROM reactions WHERE bufferId = :bufferId AND targetMsgid IN (:msgids)")
     fun observeFor(bufferId: Long, msgids: List<String>): Flow<List<ReactionEntity>>
 
+    // Buffer-scoped observe with no per-msgid IN(...) list. Scrolling back accumulates >999 loaded
+    // msgids, which would overflow SQLite's bind-variable limit in observeFor and crash; scoping by
+    // bufferId keeps one stable query and the repository filters to the visible window in memory
+    // (plans/15 #5). A buffer's reaction table is small relative to its message history.
+    @Query("SELECT * FROM reactions WHERE bufferId = :bufferId")
+    fun observeForBuffer(bufferId: Long): Flow<List<ReactionEntity>>
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun upsert(r: ReactionEntity)
 }

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

@@ -31,12 +31,21 @@ class MessageRepositoryImpl @Inject constructor(
             pagingSourceFactory = { messageDao.pagingSource(bufferId) },
         ).flow
 
+    // Kept for the frozen contract; scopes to a small, fixed msgid set (safe under 999 vars).
     override fun reactions(bufferId: Long, msgids: List<String>): Flow<List<ReactionEntity>> =
         reactionDao.observeFor(bufferId, msgids)
 
+    // Buffer-scoped observe: one stable query regardless of how far the user scrolls back, so the
+    // per-msgid IN(...) list can never exceed SQLite's ~999 bind-variable cap (plans/15 #5). The
+    // screen aggregates only the visible msgids from this stream.
+    override fun reactionsForBuffer(bufferId: Long): Flow<List<ReactionEntity>> =
+        reactionDao.observeForBuffer(bufferId)
+
     override suspend fun byMsgid(bufferId: Long, msgid: String): MessageEntity? =
         messageDao.byMsgid(bufferId, msgid)
 
     override suspend fun countNewerThan(bufferId: Long, serverTime: Long, id: Long): Int =
         messageDao.countNewerThan(bufferId, serverTime, id)
+
+    override suspend fun deleteMessage(id: Long) = messageDao.deleteById(id)
 }

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

@@ -32,8 +32,13 @@ interface MessageRepository {
     /** Paging 3 stream wired to ChatHistoryRemoteMediator (WP5 supplies mediator via factory). */
     fun messages(bufferId: Long): Flow<PagingData<MessageEntity>>
     fun reactions(bufferId: Long, msgids: List<String>): Flow<List<ReactionEntity>>
+    /** Buffer-scoped reactions (no per-msgid IN list); callers filter to the visible window
+     *  in memory to avoid SQLite's bind-variable overflow on large windows (plans/15 #5, #18). */
+    fun reactionsForBuffer(bufferId: Long): Flow<List<ReactionEntity>>
     suspend fun byMsgid(bufferId: Long, msgid: String): MessageEntity?
     suspend fun countNewerThan(bufferId: Long, serverTime: Long, id: Long): Int
+    /** Delete a locally-stored row by id (failed-echo cleanup on retry/delete, plans/15 #10). */
+    suspend fun deleteMessage(id: Long)
 }
 
 /** WP4 injects this to build its Pager; WP1 stub-binds a no-op (immediate endOfPagination),

app/src/main/kotlin/io/github/trevarj/motd/ui/chat/ChatScreen.kt

@@ -9,7 +9,6 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import io.github.trevarj.motd.data.db.BufferEntity
 import io.github.trevarj.motd.data.db.MemberEntity
 import io.github.trevarj.motd.data.db.MessageEntity
-import io.github.trevarj.motd.data.db.ReactionEntity
 import io.github.trevarj.motd.data.repo.BufferRepository
 import io.github.trevarj.motd.data.repo.LinkPreview
 import io.github.trevarj.motd.data.repo.LinkPreviewRepository
@@ -25,17 +24,15 @@ import io.github.trevarj.motd.service.TypingTracker
 import io.github.trevarj.motd.ui.nav.ChatRoute
 import androidx.navigation.toRoute
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import io.github.trevarj.motd.ui.components.ReactionChip
 import java.time.Instant
 import javax.inject.Inject
 
@@ -51,6 +48,14 @@ data class ChatState(
     val connState: IrcClientState = IrcClientState.Disconnected,
 )
 
+/**
+ * Wire text for resending a failed row. An ACTION is stored with its `/me ` prefix stripped, so
+ * re-prefix it; the manager rewrites `/me ` back into a CTCP ACTION. Non-ACTION kinds resend
+ * verbatim (plans/15 #10).
+ */
+fun resendText(kind: io.github.trevarj.motd.data.db.MessageKind, text: String): String =
+    if (kind == io.github.trevarj.motd.data.db.MessageKind.ACTION) "/me $text" else text
+
 @HiltViewModel
 class ChatViewModel @Inject constructor(
     private val savedStateHandle: SavedStateHandle,
@@ -95,9 +100,38 @@ class ChatViewModel @Inject constructor(
         )
     }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), ChatState())
 
-    /** Reactions for the currently visible msgids; the screen supplies the id set. */
-    fun reactions(msgids: List<String>): Flow<List<ReactionEntity>> =
-        messageRepository.reactions(bufferId, msgids)
+    // --- reactions aggregation (plans/15 #5, #18) ---
+
+    /** Msgids currently visible in the paging window; the screen keeps this current. */
+    private val visibleMsgids = MutableStateFlow<List<String>>(emptyList())
+
+    fun setVisibleMsgids(ids: List<String>) {
+        if (visibleMsgids.value != ids) visibleMsgids.value = ids
+    }
+
+    /**
+     * Reaction chips keyed by msgid, aggregated in the VM so the value survives across message
+     * arrivals (no blank frame from an emptyList re-seed) and picks up echo-confirm msgid swaps as
+     * soon as [visibleMsgids] changes. Buffer-scoped reactions avoid the SQLite IN(...) overflow
+     * (plans/15 #5); we filter to the visible window here.
+     */
+    val reactionChips: StateFlow<Map<String, List<ReactionChip>>> = combine(
+        messageRepository.reactionsForBuffer(bufferId),
+        visibleMsgids,
+        connState,
+    ) { all, visible, conn ->
+        val visibleSet = visible.toHashSet()
+        val relevant = all.filter { it.targetMsgid in visibleSet }
+        val myNick = (conn as? IrcClientState.Ready)?.nick
+        aggregateReactions(relevant, myNick, nickNormalizer())
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyMap())
+
+    // --- read marker snapshot (plans/15 #2) ---
+
+    // Frozen on buffer entry so the "— New messages —" divider and the FAB unread badge keep a
+    // stable boundary instead of flashing/vanishing as markRead advances the live marker.
+    private val _readMarkerSnapshot = MutableStateFlow<Long?>(null)
+    val readMarkerSnapshot: StateFlow<Long?> = _readMarkerSnapshot.asStateFlow()
 
     // --- lifecycle: foreground tracker + mark-read (plans/07) ---
 
@@ -133,8 +167,19 @@ class ChatViewModel @Inject constructor(
         connectionManager.sendReact(bufferId, msgid, emoji)
     }
 
+    /**
+     * Retry a failed message: drop the old failed row first (no permanent duplicate), then resend.
+     * An ACTION is stored with its display text stripped of the `/me ` prefix, so re-prefix it to
+     * resend as an ACTION rather than a plain PRIVMSG (plans/15 #10).
+     */
     fun retry(message: MessageEntity) = viewModelScope.launch {
-        connectionManager.sendMessage(bufferId, message.text, message.replyToMsgid)
+        messageRepository.deleteMessage(message.id)
+        connectionManager.sendMessage(bufferId, resendText(message.kind, message.text), message.replyToMsgid)
+    }
+
+    /** Delete a failed local row without resending (action-sheet delete affordance, plans/15 #10). */
+    fun deleteFailed(message: MessageEntity) = viewModelScope.launch {
+        messageRepository.deleteMessage(message.id)
     }
 
     suspend fun linkPreview(url: String): LinkPreview? = linkPreviewRepository.preview(url)
@@ -214,24 +259,47 @@ class ChatViewModel @Inject constructor(
     /** Resolved jump target (index + optional highlight msgid); null when nothing to jump to. */
     val jumpTarget: StateFlow<ChatJumpResolver.Result.Target?> = _jumpTarget.asStateFlow()
 
-    private val _jumpFailed = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
-    /** Emits when a jump could not be resolved (cap miss / not loaded) → snackbar. */
-    val jumpFailed: SharedFlow<Unit> = _jumpFailed.asSharedFlow()
+    // Nullable-event StateFlow instead of a replay-less SharedFlow so a NotFound resolved in init
+    // (before the screen subscribes) is not dropped; the UI clears it via [onJumpFailedShown]
+    // (plans/15 #13).
+    private val _jumpFailed = MutableStateFlow(false)
+    val jumpFailed: StateFlow<Boolean> = _jumpFailed.asStateFlow()
+
+    // Re-resolve is allowed exactly once per navigation; a second index shift falls through to the
+    // not-loaded snackbar rather than looping (plans/15 #12).
+    private var reresolveUsed = false
 
     init {
         if (jumpTime > 0 && savedStateHandle.get<Boolean>(JUMP_CONSUMED_KEY) != true) {
             savedStateHandle[JUMP_CONSUMED_KEY] = true
             resolveJump()
         }
+        // Freeze the read-marker once, on the first buffer emission, so the unread divider/badge
+        // stay put instead of collapsing as markRead advances the live marker (plans/15 #2).
+        viewModelScope.launch {
+            _readMarkerSnapshot.value = bufferRepository.observeBuffer(bufferId).firstOrNull()?.readMarkerTime
+        }
     }
 
     private fun resolveJump() = viewModelScope.launch {
         // The buffer name (chathistory target) may not be in `state` yet on first composition;
         // read it directly from the repo so the AROUND fallback has a target.
         val name = bufferRepository.observeBuffer(bufferId).firstOrNull()?.name
+        publishResolve(name)
+    }
+
+    private suspend fun publishResolve(name: String?) {
         when (val r = resolver.resolve(bufferId, jumpMsgid, jumpTime, name)) {
-            is ChatJumpResolver.Result.Target -> _jumpTarget.value = r
-            ChatJumpResolver.Result.NotFound -> _jumpFailed.tryEmit(Unit)
+            is ChatJumpResolver.Result.Target -> {
+                // Force a distinct emission so the screen's LaunchedEffect(jumpTarget) always
+                // re-runs, even when the re-resolved index equals the previous one (plans/15 #12).
+                _jumpTarget.value = null
+                _jumpTarget.value = r
+            }
+            ChatJumpResolver.Result.NotFound -> {
+                _jumpTarget.value = null
+                _jumpFailed.value = true
+            }
         }
     }
 
@@ -240,16 +308,24 @@ class ChatViewModel @Inject constructor(
         _jumpTarget.value = null
     }
 
-    /** Re-resolve the same target once when a live message shifted indices mid-jump. */
+    /** Screen calls this after showing the not-loaded snackbar so it does not re-fire. */
+    fun onJumpFailedShown() {
+        _jumpFailed.value = false
+    }
+
+    /**
+     * Re-resolve the same target once when a live message shifted indices mid-jump. The single-shot
+     * guard means the screen can always call [onJumpHandled] after it; a repeat request just clears
+     * the target so the not-loaded path takes over (plans/15 #12).
+     */
     fun reresolveJumpOnce() = viewModelScope.launch {
-        val name = state.value.buffer?.name
-        when (val r = resolver.resolve(bufferId, jumpMsgid, jumpTime, name)) {
-            is ChatJumpResolver.Result.Target -> _jumpTarget.value = r
-            ChatJumpResolver.Result.NotFound -> {
-                _jumpTarget.value = null
-                _jumpFailed.tryEmit(Unit)
-            }
+        if (reresolveUsed) {
+            _jumpTarget.value = null
+            _jumpFailed.value = true
+            return@launch
         }
+        reresolveUsed = true
+        publishResolve(state.value.buffer?.name)
     }
 
     /**