Split the newest reply once its turn ends, and make the UI harness reusable

The transcript's remaining lag was the newest assistant reply: transcriptUnits
kept the last row whole -- right while it streams (splitting a changing text
is a parse per delta), wrong forever after, so a session that ends on a long
reply drew it as one lazy-list item with every node alive. On a Pixel 9 Pro
XL that was 13.8ms of draw phase a frame, 79% of it the framework's own
per-node bookkeeping, against a 34,996px item.

An AssistantMsg now carries `settled`, folded from the status event that ends
its turn (status changes are transcript events with seqs, so replay settles
the same way), and cleared if a delta ever grows the message again. A settled
newest reply splits like every other. Folding it -- rather than reading the
screen's status -- routes the resplit through the held-events gate, so it can
only happen at the newest end while pinned, never under a reader. The
"session is working" predicate now lives once, in sessionWorking().

Measured on the emulator, same session and gestures, a 43KB reply as the
last row: draw phase 3.92ms -> 1.20ms per frame, framework share 3.07ms
(78%) -> 0.54ms (45%), worst single measure 82.5ms -> 9.1ms. The report's
"on screen" line went from one 60,674px AssistantMsg to five blocks of
95-846px. A live streamed turn settles and splits the moment it goes idle.

The harness half, asked for by Bryan: ui-sandbox.sh now derives its port and
root from the checkout name (two checkouts' sandboxes cannot reach each
other), keeps its token in ~/.config/ai-app/sandbox-token and salvages
enrolled device tokens across restarts (enrol the emulator once, ever), and
gained the driving verbs every UI session was re-inventing in /tmp: spawn,
send (text or @file), api. transcript-bench.sh is the standard
scroll-and-report measurement. AGENTS.md documents all of it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

app/androidApp/src/main/kotlin/com/example/aiapp/TranscriptItems.kt

@@ -45,7 +45,27 @@ sealed class TranscriptItem {
         val images: List<String> = emptyList(),
     ) : TranscriptItem()
 
-    data class AssistantMsg(override val seq: Long, val text: String) : TranscriptItem()
+    data class AssistantMsg(
+        override val seq: Long,
+        val text: String,
+        /**
+         * Whether this reply is finished: the session has stopped working since its last delta.
+         *
+         * What it buys is the split. [transcriptUnits] keeps the newest reply whole because a
+         * streaming reply's text changes per delta and splitting a changing text is a parse per
+         * delta -- but "newest" outlives the turn, so a session that ends on a long reply was
+         * drawing it as one item indefinitely, with every node of it alive. Measured on a Pixel 9
+         * Pro XL: one 34,996px reply on screen put the frame's draw phase at 13.8ms, 79% of it the
+         * framework's own bookkeeping, which grows with alive nodes.
+         *
+         * Folded from the status event that ended the turn, rather than read off the screen's
+         * status, because rows only change through the held-events gate: the split changes the
+         * newest row's list identity, and doing that from a status flip while somebody is reading
+         * inside that reply would step the list under them. An event has to wait for the reader to
+         * be at the newest end; a screen state does not.
+         */
+        val settled: Boolean = false,
+    ) : TranscriptItem()
 
     data class ToolRun(
         override val seq: Long,
@@ -362,7 +382,8 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
             // every frame, and the list would jump for the whole of a streamed answer.
             val last = items.lastOrNull()
             if (last is TranscriptItem.AssistantMsg) {
-                items.dropLast(1) + last.copy(text = last.text + event.delta)
+                // A message growing again is not finished, whatever a status said in between.
+                items.dropLast(1) + last.copy(text = last.text + event.delta, settled = false)
             } else {
                 items + TranscriptItem.AssistantMsg(entry.seq, event.delta)
             }
@@ -456,7 +477,7 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
         // is nothing it belongs above.
         is SessionEvent.MessageDropped -> items
         is SessionEvent.Settings -> items
-        is SessionEvent.Status -> items
+        is SessionEvent.Status -> settleReply(items, event.state)
         is SessionEvent.Error -> items + TranscriptItem.ErrorMsg(entry.seq, event.message)
         is SessionEvent.Image ->
             // Under the call that produced it when there is one, and a row of
@@ -479,6 +500,20 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
         is SessionEvent.UsageDelta -> items
     }
 
+/**
+ * A status saying the session stopped working is the moment its newest reply is finished.
+ *
+ * See [TranscriptItem.AssistantMsg.settled] for what the mark buys and why it is made here in the
+ * fold. Status changes are transcript events with seqs of their own, so a replayed session settles
+ * its replies the same way a live one does.
+ */
+private fun settleReply(items: List<TranscriptItem>, state: String): List<TranscriptItem> {
+    if (sessionWorking(state)) return items
+    val last = items.lastOrNull() as? TranscriptItem.AssistantMsg ?: return items
+    if (last.settled) return items
+    return items.dropLast(1) + last.copy(settled = true)
+}
+
 private fun updateTool(
     items: List<TranscriptItem>,
     id: String,