fix(chat): 低于门槛的单步思考不再消失；卡片展开收起加动画 (#20)

Two defects from the user's live test (screenshots 63329 vs 63330):

1. Lone thinking dropped. The visibility gate was ROUND-level
   (`!roundFolded || block.id in keepVisibleIds` with an always-empty
   keepVisibleIds), so once ANY run in the round carded, every block not
   owned by a card was hidden — including the lone thinking of a
   thinking→reply-text run (1 step, below the 2-step card threshold,
   nothing else to render it). The user saw the thinking bubble simply
   disappear when folding was on. The gate is block-level now
   (`block.id !in foldedBlockIds`): a block no card owns renders inline.
   Same fix in shouldShowProcessToolRow — its roundFolded branch hid
   below-threshold tool blocks the same way.

   The card threshold itself is unchanged: a run needs ≥ 2 steps
   ("超过1步则进入折叠"), one step stays inline — now visibly so.

2. Screen flash on expand/collapse. The row list appeared in a single
   frame and the whole list jumped. The card container now animates its
   size change (gentle spring), so it grows/shrinks in place while the
   list reflows around it.

Also deletes ROUND_MIN_FOLDABLE_STEPS — a dead constant (zero
references) left over from the pre-card round-fold model that only
misleads readers about the threshold.

Regression test: a carded run followed by a lone thinking + reply text —
the card forms, its steps stay inside it, and the lone thinking renders
inline.

Co-authored-by: tall-1997 <278631348+tall-1997@users.noreply.github.com>

Author: tall-1997

src/android/app/src/main/java/com/openminis/app/ui/chat/ChatAssistantMessageUI.kt

@@ -7,10 +7,13 @@ package com.openminis.app.ui.chat
 // Imports trimmed after ChatScreen.kt split; externally-called ones internal.
 
 import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.animateContentSize
 import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.Spring
 import androidx.compose.animation.core.animateFloat
 import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.spring
 import androidx.compose.animation.core.tween
 import androidx.compose.material.icons.filled.KeyboardArrowDown
 import androidx.compose.material.icons.filled.KeyboardArrowRight
@@ -1056,6 +1059,17 @@ internal fun ProcessSummaryBar(
             .border(0.5.dp, thinkingBlue.copy(alpha = 0.15f), shape)
             .clip(shape)
             .clickable(onClick = onToggle)
+            // [P-process-card] Animate the expand/collapse height change:
+            // without this the row list appears in one frame and the whole
+            // screen visibly jumps (user: "让用户感觉整个屏幕闪一下"). A
+            // gentle spring keeps the card growing/shrinking in place while
+            // the list reflows around it.
+            .animateContentSize(
+                animationSpec = spring(
+                    dampingRatio = Spring.DampingRatioLowBouncy,
+                    stiffness = Spring.StiffnessMediumLow,
+                ),
+            )
             .padding(horizontal = 12.dp, vertical = 8.dp),
     ) {
         Row(verticalAlignment = Alignment.CenterVertically) {

src/android/app/src/main/java/com/openminis/app/ui/chat/ChatFlatItems.kt

@@ -449,9 +449,6 @@ internal data class ProcessStepRef(
     val block: AssistantBlock,
 )
 
-/** Rounds with fewer foldable steps than this never fold (rule 1). */
-private const val ROUND_MIN_FOLDABLE_STEPS = 3
-
 /** A process run shorter than this stays inline (a card for one row is noise). */
 private const val SEGMENT_MIN_STEPS = 2
 
@@ -813,6 +810,14 @@ internal fun buildFlatChatItems(
         // list for good — expanding the card renders them INSIDE the card.
         // A card the user has not opened folds its steps; a card they opened
         // (its own key, not the round's) keeps them in the card either way.
+        //
+        // [P-process-card-single-step] foldedBlockIds is BLOCK-level: only
+        // the blocks of runs that actually became cards. A run below the
+        // 2-step threshold (a lone thinking before reply text) never cards,
+        // so its blocks stay OUT of foldedBlockIds and must keep rendering
+        // inline — the old `!roundFolded || in keepVisibleIds` gate hid
+        // them whenever ANY card existed in the round, which silently
+        // dropped the lone thinking (user: "只有一步思考的气泡被丢弃了").
         val foldedBlockIds: Set<String> = if (round == null || isSystem) {
             emptySet()
         } else {
@@ -831,8 +836,7 @@ internal fun buildFlatChatItems(
             when (block.kind) {
                 "text" -> block.content.isNotEmpty()
                 "info" -> true
-                "thinking" -> block.id !in foldedBlockIds &&
-                    (!roundFolded || block.id in keepVisibleIds)
+                "thinking" -> block.id !in foldedBlockIds
                 "tool_use" -> block.id !in foldedBlockIds && shouldShowProcessToolRow(
                     block,
                     showCompletedToolCards = showCompletedToolCards,
@@ -950,7 +954,10 @@ internal fun buildFlatChatItems(
                     }
                 }
                 "thinking" -> {
-                    if (block.id !in foldedBlockIds && (!roundFolded || block.id in keepVisibleIds)) {
+                    // [P-process-card-single-step] Block-level gate: a
+                    // thinking block not owned by any card renders inline,
+                    // whether or not sibling runs in the round carded.
+                    if (block.id !in foldedBlockIds) {
                         out.add(dedupe(FlatChatItem.AssistantThinking(
                             messageId = message.id,
                             block = block,
@@ -1090,15 +1097,18 @@ internal fun shouldShowProcessToolRow(
     block: AssistantBlock,
     showCompletedToolCards: Boolean,
     foldAiProcess: Boolean,
-    roundFolded: Boolean,
-    keepVisibleIds: Set<String>,
+    @Suppress("UNUSED_PARAMETER") roundFolded: Boolean,
+    @Suppress("UNUSED_PARAMETER") keepVisibleIds: Set<String>,
 ): Boolean {
     if (isAlwaysVisibleProcessTool(block)) return true
-    // A tool the process card already owns never renders a second copy in
-    // the list, running or not — the card header names the live step.
-    // isInFlightProcessTool only decides the fold-OFF list, where there is
-    // no card to hold it.
-    if (roundFolded) return block.id in keepVisibleIds
+    // [P-process-card-single-step] No round-level gate here: every caller
+    // has already filtered `block.id !in foldedBlockIds`, so a block that
+    // reaches this function belongs to a run that did NOT card (below the
+    // 2-step threshold) and must render inline. The old
+    // `if (roundFolded) return block.id in keepVisibleIds` hid those
+    // blocks whenever any sibling run in the round carded — dropping a
+    // lone tool the same way the lone thinking was dropped. Card-owned
+    // blocks never reach here; the block-level check upstream is the gate.
     if (isInFlightProcessTool(block)) return true
     // Fold mode owns visibility: a running or user-expanded round shows every
     // step in-thread (the fold bar no longer carries tool chips, so hiding

src/android/app/src/test/java/com/openminis/app/ui/chat/ChatFlatItemsProcessFoldTest.kt

@@ -116,6 +116,40 @@ class ChatFlatItemsProcessFoldTest {
         assertEquals(2, summary.toolCount)
     }
 
+    @Test
+    fun `a lone thinking after a carded run stays inline`() {
+        // [P-process-card-single-step] Regression: the visibility gate used
+        // to be ROUND-level (`!roundFolded || in keepVisibleIds`), so once
+        // any run in the round carded, a LONE thinking block from a
+        // below-threshold run (thinking → reply text, one step) was hidden
+        // with nowhere to render — the user lost the thinking entirely
+        // ("只有一步思考的气泡被丢弃了"). The gate is block-level now: a
+        // block no card owns renders inline.
+        val items = buildFlatChatItems(
+            listOf(
+                assistant(
+                    blocks = listOf(
+                        thinking(id = "th1"),
+                        tool(id = "t1"),
+                        tool(id = "t2"),
+                        text(id = "tx1", content = "reply"),
+                        thinking(id = "th2"),
+                        text(id = "tx2", content = "tail"),
+                    ),
+                ),
+            ),
+            showCompletedToolCards = false,
+            foldAiProcess = true,
+        )
+        val k = kinds(items)
+        // The carded run (3 steps) is a summary and its steps are inside it.
+        assertTrue(k.contains("summary"))
+        assertFalse(k.contains("tool:bash"))
+        // The lone thinking after the reply text stays inline — it belongs
+        // to no card.
+        assertTrue(k.contains("thinking"))
+    }
+
     @Test
     fun `a two step run becomes a card and a single step stays inline`() {
         // [P-process-card] The card threshold is the RUN, not the round: