Fetch the transcript instead of replaying it one event at a time

**The five seconds of loading top-down.** Opening a session subscribed to
the event stream from sequence zero, so the backlog arrived as one SSE
frame per event -- 864 of them for an imported conversation, rendered as
they landed. That is not a slow list; it is a conversation being replayed
at network speed, and it looks like loading from the top because it is.

The newest page now comes as one request, and the stream starts from where
that page ended, carrying live events only -- which is what a stream is
good at. Scrolling back fetches the page before it, so history costs
something only when somebody actually reads it. 80 events instead of 864,
and the first frame is already the end of the conversation.

I had called this fixed after anchoring the list at the bottom, on the
strength of an emulator on the same machine as the server. That test could
not have shown the problem: the whole backlog arrived in one frame's worth
of time over loopback. Iris's phone, over a tunnel, took five seconds.

**Send disappearing while running.** It was never conditional -- the row
simply ran out of width. A Row hands out intrinsic widths in order and
clips the overflow, so when Stop appeared the pickers I had added pushed
Send off the screen: the app's central control, gone at exactly the moment
the app is most in use. The settings now share what is left after the
actions have taken what they need.

While a turn is in flight the button says **Queue**, because that is what
sending then does -- the message is injected at the next tool boundary
rather than starting a turn of its own. The backend has always done this;
the button was describing something else.

**And the model picker no longer dismisses the keyboard**, which it did by
taking focus. Changing the model mid-sentence is an aside, not a departure
from what you were typing.

Verified on the 864-event import: at the newest message within a second,
history paging back continuously past the first page, and Stop beside
Queue while running.

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

@@ -439,6 +439,31 @@ fun deleteImportable(settings: ServerSettings, setup: String, sessionId: String)
     requestFromServer(settings, "/setups/$setup/importable/$sessionId", method = "DELETE") {}
 }
 
+/**
+ * A page of a session's transcript, oldest first within the page.
+ *
+ * One request instead of one stream frame per event. The SSE stream is the right shape for live
+ * events and the wrong one for a backlog: opening an imported session replayed hundreds of frames
+ * before anything was readable, which looked exactly like the app loading top-down, because it was.
+ *
+ * [before] pages backwards for history somebody scrolls to; absent means the newest page.
+ */
+fun fetchTranscript(
+    settings: ServerSettings,
+    sessionId: String,
+    before: Long? = null,
+    limit: Int = 80,
+): List<SeqEvent> {
+    val query = buildString {
+        append("?limit=").append(limit)
+        if (before != null) append("&before=").append(before)
+    }
+    return requestFromServer(settings, "/sessions/$sessionId/transcript$query") { connection ->
+        val body = JSONArray(connection.inputStream.bufferedReader().readText())
+        (0 until body.length()).map { parseSeqEvent(body.getJSONObject(it).toString()) }
+    }
+}
+
 /** Switches a running session's model; the CLI changes it in place. */
 fun setSessionModel(settings: ServerSettings, sessionId: String, model: String) {
     requestFromServer(