bc6b45e · opencode-android

git.iko.soy/opencode-android

Fix queued follow-up loss across process death, a SharedFlow stall from synchronous notification dispatch, and several UI/state races (draft echo clobbering, reasoning collapse during streaming, permission dialog back handling, diff header misclassification, remote image same-origin guard, file browser search refresh, undo snackbar dead-Undo buttons, deleted session resurrected mid-undo, cancellable crash-report read)

commitbc6b45e551a32d07201b0b5a00559d0aa8e4f3b4 authoriko <mail@iko.soy> dateWed 1 Jul 2026, 16:21 (3 months ago) parentcec3303

13 files changed+198−43

compare with master

unifiedsplit

app/src/main/java/soy/iko/opencode/data/repo/DraftStore.kt+59−6

@@ -55,6 +55,11 @@ open class DraftStore private constructor(

5555 /** The full in-memory snapshot of all drafts, updated when prefs finish loading. */

5656 open val drafts: StateFlow<Map<String, String>> = _drafts.asStateFlow()

5757

58+ /** Queued follow-up messages per session, persisted under a namespaced key so a

59+ * follow-up queued mid-run survives process death (the in-memory-only StateFlow in

60+ * ChatViewModel would otherwise lose it, along with the cleared draft). */

61+ private val _followUps = MutableStateFlow<Map<String, String>>(emptyMap())

62+

5863 private val _ready = MutableStateFlow(false)

5964 /** True once the background prefs load has completed. */

6065 open val ready: StateFlow<Boolean> = _ready.asStateFlow()

@@ -65,16 +70,23 @@ open class DraftStore private constructor(

6570 // so callers can observe readiness without blocking.

6671 if (scope != null && appContext != null) {

6772 scope.launch(Dispatchers.IO) {

68− val snapshot = runCatching {

73+ val all = runCatching {

6974 prefs.all.mapValues { it.value as? String ?: "" }

7075 }.getOrDefault(emptyMap())

76+ // Partition persisted keys: follow-up keys carry a prefix, everything else

77+ // is a plain per-session draft.

78+ val drafts = mutableMapOf<String, String>()

79+ val followUps = mutableMapOf<String, String>()

80+ all.forEach { (k, v) ->

81+ if (k.startsWith(FOLLOWUP_PREFIX)) followUps[k.removePrefix(FOLLOWUP_PREFIX)] = v

82+ else drafts[k] = v

83+ }

7184 // Merge instead of overwriting: any in-memory writes that arrived before

7285 // the background load completed (e.g. a share-intent draft injected via

7386 // setImmediate) take priority over the persisted snapshot so they aren't

7487 // clobbered.

75− _drafts.update { current ->

76− snapshot.toMutableMap().apply { putAll(current) }

77− }

88+ _drafts.update { current -> drafts.apply { putAll(current) } }

89+ _followUps.update { current -> followUps.apply { putAll(current) } }

7890 _ready.value = true

7991 }

8092 } else {

@@ -85,6 +97,35 @@ open class DraftStore private constructor(

8597 /** Returns the draft for [sessionId], or "" if not found or still loading. */

8698 open fun get(sessionId: String): String = _drafts.value[sessionId].orEmpty()

8799

100+ /** Returns the queued follow-up for [sessionId], or "" if none / still loading. */

101+ open fun getFollowUp(sessionId: String): String = _followUps.value[sessionId].orEmpty()

102+

103+ /** Persist a queued follow-up immediately (fire-and-forget, main-thread-safe).

104+ * Mirrors [flushDraft]: async apply() when prefs are open, else a background thread,

105+ * so a follow-up queued just before process death is flushed before the process exits.

106+ * A blank [text] clears the stored follow-up. */

107+ open fun flushFollowUp(sessionId: String, text: String) {

108+ _followUps.update { current ->

109+ val updated = current.toMutableMap()

110+ if (text.isBlank()) updated.remove(sessionId) else updated[sessionId] = text

111+ updated

112+ }

113+ writeAsync(FOLLOWUP_PREFIX + sessionId, text)

114+ }

115+

116+ /** Persist [key]=[text] (or remove it when blank) without blocking the main thread on

117+ * first-time disk I/O — see [flushDraft] for the prefs-not-yet-open rationale. */

118+ private fun writeAsync(key: String, text: String) {

119+ val write = {

120+ runCatching {

121+ prefs.edit().apply {

122+ if (text.isBlank()) remove(key) else putString(key, text)

123+ }.apply()

124+ }.onFailure { Log.w("DraftStore", "Failed to persist $key", it) }

125+ }

126+ if (prefsInitialized.get()) write() else flushExecutor.execute { write() }

127+ }

128+

88129 /** Update the in-memory draft immediately without persisting to disk.

89130 * Used when navigation must see the new value synchronously (e.g. share-intent

90131 * injection before ChatScreen composes). Call [set] afterwards to persist. */

@@ -111,16 +152,22 @@ open class DraftStore private constructor(

111152 }

112153 }

113154

114− /** Remove the draft for a session (call on session deletion to avoid orphaned entries). */

155+ /** Remove the draft for a session (call on session deletion to avoid orphaned entries).

156+ * Also clears any queued follow-up so a deleted session leaves nothing behind. */

115157 open suspend fun remove(sessionId: String) {

116158 _drafts.update { current ->

117159 val updated = current.toMutableMap()

118160 updated.remove(sessionId)

119161 updated

120162 }

163+ _followUps.update { current ->

164+ val updated = current.toMutableMap()

165+ updated.remove(sessionId)

166+ updated

167+ }

121168 withContext(Dispatchers.IO) {

122169 runCatching {

123− prefs.edit().remove(sessionId).apply()

170+ prefs.edit().remove(sessionId).remove(FOLLOWUP_PREFIX + sessionId).apply()

124171 }.onFailure { Log.w("DraftStore", "Failed to remove draft for $sessionId", it) }

125172 }

126173 }

@@ -166,6 +213,12 @@ open class DraftStore private constructor(

166213 }

167214 }

168215

216+ private companion object {

217+ /** Key prefix distinguishing persisted follow-ups from plain drafts in the shared

218+ * prefs file. Uses a NUL so it can't collide with a real session id. */

219+ const val FOLLOWUP_PREFIX = "followup"

220+ }

221+

169222 /** Shut down the background flush executor. Call from AppContainer.shutdown(). */

170223 open fun shutdown() {

171224 flushExecutor.shutdown()

app/src/main/java/soy/iko/opencode/di/AppContainer.kt+6−1

@@ -261,7 +261,12 @@ open class AppContainer private constructor(

261261 }

262262 }

263263 if (wasRunning && idleSid != _currentSession.value) {

264− notifySessionCompleted(idleSid)

264+ // Fire this off the collector's coroutine: notifySessionCompleted

265+ // does a network listSessions() to resolve the title, and blocking

266+ // the shared-event collector here would stall the SharedFlow,

267+ // overflowing its DROP_OLDEST buffer and silently dropping live

268+ // parts/updates for every other subscriber (e.g. the message reducer).

269+ appScope.launch { notifySessionCompleted(idleSid) }

265270 }

266271 return@collect

267272 }

app/src/main/java/soy/iko/opencode/notification/SessionNotifications.kt+4−3

@@ -73,9 +73,10 @@ object SessionNotifications {

7373 val notification = NotificationCompat.Builder(context, NotificationChannels.COMPLETED)

7474 .setSmallIcon(R.drawable.ic_launcher_foreground)

7575 .setContentTitle(context.getString(R.string.notif_completed_title))

76− // Escape % characters in the title so getString formatting doesn't break

77− // when a server-controlled session title contains format-specifier-like text.

78− .setContentText(context.getString(R.string.notif_completed_text, title.replace("%", "%%")))

76+ // No % escaping here: getString(id, arg) inserts the argument verbatim and

77+ // never re-scans it for format specifiers, so escaping the title would show

78+ // literal doubled percent signs (e.g. a "50% done" title as "50%% done").

79+ .setContentText(context.getString(R.string.notif_completed_text, title))

7980 .setAutoCancel(true)

8081 .setContentIntent(pendingIntent)

8182 .setCategory(NotificationCompat.CATEGORY_MESSAGE)

app/src/main/java/soy/iko/opencode/ui/chat/ChatViewModel.kt+52−7

@@ -83,6 +83,12 @@ class ChatViewModel(

8383 * debounce timer firing before the send completes. */

8484 private val suppressDraftPersist = java.util.concurrent.atomic.AtomicBoolean(false)

8585

86+ /** The draft value this VM last persisted, so the drafts observer can tell its own

87+ * (debounced, possibly stale) echo apart from a genuine external write. Without this

88+ * a debounced persist of an older value could echo back and overwrite newer text the

89+ * user has since typed. */

90+ @Volatile private var lastPersistedDraft: String? = null

91+

8692 /** Per-catalog reload triggers: incrementing one causes [observeCatalog]'s

8793 * collectLatest to cancel any in-flight fetch and start a fresh one, so a

8894 * manual reload supersedes a stale observeCatalog fetch. */

@@ -221,9 +227,24 @@ class ChatViewModel(

221227 // Observe the ready signal and re-seed the draft so it appears in the UI.

222228 viewModelScope.launch {

223229 container.draftStore.ready.collect { ready ->

224− if (ready && _draft.value.isEmpty()) {

230+ if (!ready) return@collect

231+ if (_draft.value.isEmpty()) {

225232 _draft.value = container.draftStore.get(sessionId)

226233 }

234+ // Recover a follow-up queued before process death (its in-memory StateFlow

235+ // is gone). If the input is now free, drop it back there for review/send and

236+ // consume the stored copy; otherwise re-queue it so it auto-sends when the

237+ // current run next idles. Guarded on == null so it never clobbers a

238+ // follow-up the user queued after opening this session.

239+ val savedFollowUp = container.draftStore.getFollowUp(sessionId)

240+ if (savedFollowUp.isNotEmpty() && _queuedFollowUp.value == null) {

241+ if (_draft.value.isEmpty()) {

242+ _draft.value = savedFollowUp

243+ container.draftStore.flushFollowUp(sessionId, "")

244+ } else {

245+ _queuedFollowUp.value = savedFollowUp

246+ }

247+ }

227248 }

228249 }

229250 // Observe the drafts store for external mutations to this session's draft

@@ -238,7 +259,16 @@ class ChatViewModel(

238259 // pre-send draft until the send resolves).

239260 viewModelScope.launch {

240261 container.draftStore.drafts.collect { drafts ->

262+ // Ignore emissions until the initial disk load completes: the load itself

263+ // emits the persisted snapshot, and applying it here would clobber text the

264+ // user typed during the async load (the `ready` observer above seeds an

265+ // empty draft). After ready, emissions are external writes.

266+ if (!container.draftStore.ready.value) return@collect

241267 val storeValue = drafts[sessionId].orEmpty()

268+ // Ignore this VM's own (debounced, possibly stale) persistence echo — only a

269+ // genuine external write (e.g. a two-pane share injection) should overwrite

270+ // the live draft.

271+ if (storeValue == lastPersistedDraft) return@collect

242272 if (storeValue != _draft.value && !suppressDraftPersist.get()) {

243273 _draft.value = storeValue

244274 }

@@ -322,6 +352,7 @@ class ChatViewModel(

322352 viewModelScope.launch {

323353 _draft.drop(1).debounce(NetworkConfig.draftDebounceMs).collect { text ->

324354 if (text.isBlank() && suppressDraftPersist.get()) return@collect

355+ lastPersistedDraft = text

325356 runCatchingCancellable { container.draftStore.set(sessionId, text) }

326357 .onFailure { Log.w("ChatViewModel", "Failed to persist draft", it) }

327358 }

@@ -335,7 +366,10 @@ class ChatViewModel(

335366 _running.value = false

336367 _pendingPermission.value = null

337368 _failedDraft.value = null

338− _queuedFollowUp.value = null

369+ // NOTE: deliberately not clearing _queuedFollowUp here. It's session-scoped

370+ // user intent that is now persisted; wiping it on every (re)connect — which

371+ // this collector does, including transient SSE drops and the cold-start

372+ // restore path — would drop a legitimately queued/recovered follow-up.

339373 _selectedAgent.value = null

340374 _sessionTitle.value = null

341375 try {

@@ -346,13 +380,13 @@ class ChatViewModel(

346380 // so the user's drafted-while-running message isn't lost.

347381 val queued = _queuedFollowUp.value

348382 if (queued != null) {

349− _queuedFollowUp.value = null

383+ setQueuedFollowUp(null)

350384 send(queued)

351385 }

352386 }

353387 if (SessionRepository.isError(event, sessionId)) {

354388 _running.value = false

355− _queuedFollowUp.value = null

389+ setQueuedFollowUp(null)

356390 _errorEvents.tryEmit(container.string(R.string.error_agent_reported))

357391 }

358392 when (event) {

@@ -492,7 +526,10 @@ class ChatViewModel(

492526 // typed a new one while the send was in flight. Otherwise clearing the

493527 // store echoes back through the draft observer and wipes the in-progress

494528 // text (data loss). Mirrors the guard on the failure path above.

495− if (_draft.value.isBlank()) container.draftStore.set(sessionId, "")

529+ if (_draft.value.isBlank()) {

530+ lastPersistedDraft = ""

531+ container.draftStore.set(sessionId, "")

532+ }

496533 // Don't reset _running here: the agent continues streaming via SSE.

497534 // _running is cleared on SessionIdle/SessionError (see event collector)

498535 // or when the SSE stream drops (see connection state watcher below).

@@ -520,13 +557,21 @@ class ChatViewModel(

520557 */

521558 fun queueFollowUp(text: String) {

522559 val trimmed = text.trim()

523− _queuedFollowUp.value = trimmed.takeIf { it.isNotEmpty() }

560+ setQueuedFollowUp(trimmed.takeIf { it.isNotEmpty() })

524561 // The text now lives in the queued chip, so clear the input field just as a

525562 // normal send would. No-op for the cancel case (blank text), which must leave

526563 // whatever the user has since typed untouched.

527564 if (trimmed.isNotEmpty()) _draft.value = ""

528565 }

529566

567+ /** Set or clear the queued follow-up and mirror it to persistence, so a follow-up

568+ * queued mid-run survives process death (recovered on the next open of this session).

569+ * Passing null / blank clears both the in-memory value and the persisted copy. */

570+ private fun setQueuedFollowUp(text: String?) {

571+ _queuedFollowUp.value = text

572+ container.draftStore.flushFollowUp(sessionId, text.orEmpty())

573+ }

574+

530575 /** Transient flag set by [refreshMessages] so the top-bar refresh icon can show

531576 * a brief spinner as immediate tap feedback. The SSE reconnect triggered by

532577 * refreshMessages may not visibly change [connectionState] (it's already

@@ -570,7 +615,7 @@ class ChatViewModel(

570615 val conn = connection ?: return

571616 // Drop any queued follow-up so the SessionIdle that follows the abort doesn't

572617 // auto-send it — the user tapped Stop to halt work, not to trigger the next turn.

573− _queuedFollowUp.value = null

618+ setQueuedFollowUp(null)

574619 if (!_aborting.compareAndSet(false, true)) return

575620 viewModelScope.launch {

576621 try {

app/src/main/java/soy/iko/opencode/ui/chat/PartRenderer.kt+8−6

@@ -111,7 +111,7 @@ fun PartView(

111111 is TextPart -> if (!part.ignored && part.text.isNotEmpty()) {

112112 MarkdownText(part.text, modifier = modifier, streaming = isRunning)

113113 }

114− is ReasoningPart -> ReasoningBlock(part.text, streaming = isRunning, modifier)

114+ is ReasoningPart -> ReasoningBlock(part.text, streaming = isRunning, keyId = part.id, modifier = modifier)

115115 is ToolPart -> ToolCallView(part, modifier)

116116 is FilePart -> if (part.isImage && imageContext != null && (part.source != null || !part.url.isNullOrBlank())) {

117117 RemoteImage(part, imageContext, modifier)

@@ -149,13 +149,15 @@ private fun UnknownPartNote(modifier: Modifier) {

149149}

150150

151151@Composable

152−private fun ReasoningBlock(text: String, streaming: Boolean, modifier: Modifier) {

152+private fun ReasoningBlock(text: String, streaming: Boolean, keyId: String, modifier: Modifier) {

153153 if (text.isBlank()) return

154154 val context = LocalContext.current

155− // Key the expanded state on a content prefix so a new ReasoningPart (e.g. a second

156− // reasoning block added during streaming) doesn't inherit the positional saveable

157− // key of a prior block and start in the wrong expanded state.

158− var expanded by rememberSaveable(text.take(64)) { mutableStateOf(false) }

155+ // Key the expanded state on the part's stable id so a new ReasoningPart doesn't

156+ // inherit the positional saveable key of a prior block. A content-prefix key would

157+ // change on nearly every token while streaming and snap the block back to collapsed;

158+ // fall back to a content prefix only when the part has no id.

159+ val saveableKey = keyId.ifBlank { text.take(64) }

160+ var expanded by rememberSaveable(saveableKey) { mutableStateOf(false) }

159161 val expandedState = stringResource(R.string.state_expanded)

160162 val collapsedState = stringResource(R.string.state_collapsed)

161163 val thinkingLabel = stringResource(R.string.thinking)

app/src/main/java/soy/iko/opencode/ui/chat/PermissionDialog.kt+6−4

@@ -5,7 +5,6 @@ import androidx.compose.foundation.layout.Column

55import androidx.compose.foundation.layout.Row

66import androidx.compose.foundation.layout.fillMaxWidth

77import androidx.compose.foundation.layout.padding

8−import androidx.activity.compose.BackHandler

98import androidx.compose.material.icons.Icons

109import androidx.compose.material.icons.filled.Shield

1110import androidx.compose.material3.AlertDialog

@@ -50,10 +49,13 @@ fun PermissionDialog(

5049 onRespond(response)

5150 }

5251 }

53− // Intercept back so the dialog can't be dismissed without an explicit choice.

54− BackHandler { respond(PermissionResponse.REJECT) }

5552 AlertDialog(

56− onDismissRequest = { /* require an explicit choice */ },

53+ // Back press routes here (dismissOnBackPress defaults true) and is treated as an

54+ // explicit reject — the safe default. Tap-outside is disabled below so it can't

55+ // dismiss silently. A host-composition BackHandler doesn't work: AlertDialog

56+ // renders in its own window whose back dispatcher never reaches the host.

57+ onDismissRequest = { respond(PermissionResponse.REJECT) },

58+ properties = androidx.compose.ui.window.DialogProperties(dismissOnClickOutside = false),

5759 icon = { Icon(Icons.Filled.Shield, contentDescription = null) },

5860 title = { Text(permission.title ?: stringResource(R.string.permission_title)) },

5961 text = {

app/src/main/java/soy/iko/opencode/ui/components/DiffView.kt+6−1

@@ -61,7 +61,12 @@ private fun isDiffFileHeader(raw: String): Boolean {

6161 raw.startsWith("+++ ") -> raw.substring(4)

6262 else -> return false

6363 }

64− return rest.startsWith("a/") || rest.startsWith("b/") || rest.startsWith("/")

64+ // Header paths are "a/…", "b/…", or the literal "/dev/null" (optionally followed by a

65+ // tab/space-separated timestamp). Restricting the absolute-path case to /dev/null avoids

66+ // misclassifying a removed content line like "-- /usr/local/foo" (on the wire

67+ // "--- /usr/local/foo"), whose rest starts with "/", as a file header.

68+ return rest.startsWith("a/") || rest.startsWith("b/") ||

69+ rest == "/dev/null" || rest.startsWith("/dev/null\t") || rest.startsWith("/dev/null ")

6570}

6671

6772/** Parse a unified diff string into typed [DiffLine]s. */

app/src/main/java/soy/iko/opencode/ui/components/RemoteImage.kt+13−6

@@ -69,15 +69,22 @@ private fun FilePart.resolveModel(ctx: ImageLoadContext): Any? {

6969 return if (url.startsWith("http://") || url.startsWith("https://")) {

7070 url

7171 } else {

72− // Resolve relative URL against the base. Collapse any ../ segments to

73− // prevent path traversal from escaping the server's base path.

72+ // Resolve the URL (relative or server-absolute like "/media/x.png") against the

73+ // base, collapsing any ../ segments.

7474 val base = HttpClientFactory.normalizeBaseUrl(ctx.baseUrl)

75+ val baseUri = runCatching { java.net.URI(base) }.getOrElse { return null }

7576 val resolved = runCatching {

76− java.net.URI(base).resolve(url).normalize().toString()

77+ java.net.URI(base).resolve(url).normalize()

7778 }.getOrElse { return null }

78− // Guard: if normalization escaped the base path, return null (don't

79− // attempt to load the base URL itself as an image — it's not one).

80− if (!resolved.startsWith(base)) null else resolved

79+ // Guard on same origin (scheme + host + port), not base-path prefix: the real

80+ // risk is redirecting the request (with its Basic auth) to another host. A

81+ // server-absolute path resolves to a different base *path* but the same origin,

82+ // so it must still be allowed — a prefix check wrongly rejected those.

83+ val sameOrigin = resolved.host != null &&

84+ resolved.scheme.equals(baseUri.scheme, ignoreCase = true) &&

85+ resolved.host.equals(baseUri.host, ignoreCase = true) &&

86+ resolved.port == baseUri.port

87+ if (sameOrigin) resolved.toString() else null

8188 }

8289}

8390

app/src/main/java/soy/iko/opencode/ui/file/FileBrowserViewModel.kt+12−6

@@ -98,15 +98,21 @@ class FileBrowserViewModel(private val container: AppContainer) : ViewModel() {

9898 }

9999 }

100100

101− /** Re-open the current directory (manual refresh). Used by pull-to-refresh. */

101+ /** Re-run the current view (manual refresh). Used by pull-to-refresh. */

102102 fun refresh() {

103103 _refreshing.value = true

104− open(_state.value.path)

104+ val searching = _state.value.isSearching

105+ if (searching) {

106+ // Re-run the active search rather than open(), which would reset query/results

107+ // and drop the user back into the directory listing — discarding their search.

108+ setQuery(_state.value.query)

109+ } else {

110+ open(_state.value.path)

111+ }

105112 viewModelScope.launch {

106− // Clear the spinner once the open() launch settles. open() sets loading=true

107− // synchronously and flips it false in its own coroutine; wait one frame cycle.

108− // Simpler: clear after the openJob completes by joining it.

109− openJob?.join()

113+ // Clear the spinner once the in-flight load settles by joining whichever job

114+ // the refresh kicked off (search or directory open).

115+ (if (searching) searchJob else openJob)?.join()

110116 _refreshing.value = false

111117 }

112118 }

app/src/main/java/soy/iko/opencode/ui/server/ServerListScreen.kt+7−1

@@ -62,6 +62,7 @@ import androidx.compose.ui.res.stringResource

6262import androidx.lifecycle.compose.collectAsStateWithLifecycle

6363import androidx.lifecycle.viewmodel.compose.viewModel

6464import kotlinx.coroutines.coroutineScope

65+import kotlinx.coroutines.flow.collectLatest

6566import kotlinx.coroutines.delay

6667import kotlinx.coroutines.launch

6768import soy.iko.opencode.data.model.ServerProfile

@@ -114,7 +115,12 @@ fun ServerListScreen(

114115 // (~10s) outlasted the window, leaving the button on screen but dead for its

115116 // second half. Mirrors DiagnosticsScreen's undo pattern.

116117 LaunchedEffect(Unit) {

117− vm.undoEvents.collect { profileId ->

118+ // collectLatest (not collect): a serialized collect queues each snackbar behind

119+ // the previous one's full window, so under rapid deletes a later profile's VM

120+ // delete timer (started at emit time) fires before its snackbar is ever shown —

121+ // a dead Undo button. collectLatest instead cancels the current snackbar and

122+ // shows the newest immediately, keeping its Undo window aligned with its timer.

123+ vm.undoEvents.collectLatest { profileId ->

118124 coroutineScope {

119125 val dismisser = launch {

120126 delay(NetworkConfig.undoServerDeleteDelayMs)

app/src/main/java/soy/iko/opencode/ui/session/SessionListScreen.kt+7−1

@@ -78,6 +78,7 @@ import androidx.compose.ui.res.stringResource

7878import androidx.lifecycle.compose.collectAsStateWithLifecycle

7979import androidx.lifecycle.viewmodel.compose.viewModel

8080import kotlinx.coroutines.coroutineScope

81+import kotlinx.coroutines.flow.collectLatest

8182import kotlinx.coroutines.delay

8283import kotlinx.coroutines.launch

8384import soy.iko.opencode.data.model.ServerProfile

@@ -146,7 +147,12 @@ fun SessionListScreen(

146147 // SnackbarDuration.Long (~10s) outlasted the window, leaving the button on screen

147148 // but dead for its second half. Mirrors DiagnosticsScreen's undo pattern.

148149 LaunchedEffect(Unit) {

149− vm.undoEvents.collect { sessionId ->

150+ // collectLatest (not collect): a serialized collect queues each snackbar behind

151+ // the previous one's full window, so under rapid deletes a later session's VM

152+ // delete timer (started at emit time) fires before its snackbar is ever shown —

153+ // a dead Undo button. collectLatest instead cancels the current snackbar and

154+ // shows the newest immediately, keeping its Undo window aligned with its timer.

155+ vm.undoEvents.collectLatest { sessionId ->

150156 coroutineScope {

151157 val dismisser = launch {

152158 delay(NetworkConfig.undoDeleteDelayMs)

app/src/main/java/soy/iko/opencode/ui/session/SessionListViewModel.kt+14

@@ -192,6 +192,11 @@ class SessionListViewModel(private val container: AppContainer) : ViewModel() {

192192 when (event) {

193193 is SessionUpdated -> {

194194 val session = event.properties.info

195+ // Ignore updates for a session the user just deleted (still

196+ // within its undo window): the server hasn't deleted it yet

197+ // and can legitimately emit updates, but buffering them here

198+ // would resurrect the optimistically-hidden row mid-undo.

199+ if (pendingDeletes.containsKey(session.id)) return@collect

195200 pendingSessionUpdates[session.id] = session

196201 if (sessionUpdateJob?.isActive != true) {

197202 sessionUpdateJob = viewModelScope.launch {

@@ -204,6 +209,9 @@ class SessionListViewModel(private val container: AppContainer) : ViewModel() {

204209 val id = event.properties.info?.id ?: event.properties.sessionID

205210 if (id != null) {

206211 synchronized(previewLock) { livePreviewJobs.remove(id)?.cancel() }

212+ // Drop any buffered update for this id so a pending flush

213+ // can't re-add the just-deleted session to the list.

214+ pendingSessionUpdates.remove(id)

207215 container.draftStore.remove(id)

208216 _state.update { s ->

209217 s.copy(

@@ -239,6 +247,9 @@ class SessionListViewModel(private val container: AppContainer) : ViewModel() {

239247 val byId = s.sessions.associateBy { it.id }.toMutableMap()

240248 var anyChanged = false

241249 batch.forEach { (id, session) ->

250+ // Final guard: never re-add a session that's pending deletion (its undo

251+ // window is still open), even if an update slipped into this batch.

252+ if (id in pendingDeletes) return@forEach

242253 if (byId[id] != session) { byId[id] = session; anyChanged = true }

243254 }

244255 // No-op update: skip the rebuild entirely so the StateFlow doesn't emit a

@@ -399,6 +410,9 @@ class SessionListViewModel(private val container: AppContainer) : ViewModel() {

399410 }

400411 // Hold the pending delete so the snackbar can undo it.

401412 pendingDeletes[session.id] = session

413+ // Drop any already-buffered update for this session so a pending flush during the

414+ // undo window can't re-add the row we just optimistically hid.

415+ pendingSessionUpdates.remove(session.id)

402416 _undoEvents.tryEmit(session.id)

403417 viewModelScope.launch {

404418 delay(NetworkConfig.undoDeleteDelayMs)

app/src/main/java/soy/iko/opencode/ui/settings/DiagnosticsScreen.kt+4−1

@@ -229,7 +229,10 @@ fun DiagnosticsScreen(onBack: () -> Unit) {

229229 var loadFailed by remember(reportName) { mutableStateOf(false) }

230230 LaunchedEffect(reportName) {

231231 val loaded = withContext(Dispatchers.IO) {

232− runCatching { logger.readReport(reportName) }.getOrNull()

232+ // runCatchingCancellable (not runCatching) so dismissing the dialog or

233+ // switching reports mid-read lets the CancellationException propagate

234+ // instead of being swallowed and setting state on a torn-down effect.

235+ runCatchingCancellable { logger.readReport(reportName) }.getOrNull()

233236 }

234237 if (loaded != null) reportContent = loaded else loadFailed = true

235238 }