Name a run of tool calls once, instead of after whichever call is first

A group of adjacent tool calls was identified by its first call, and the
list is keyed by that identity. But a run can gain members at *either*
end -- a new call arriving beside it, or a page of history arriving in
front of it -- so its first member is not a name, it is a description
that changes. Every time it changed, the row was a different row as far
as the list was concerned: the anchor went with it, and the transcript
stepped under whoever was reading.

Each call now carries the run it belongs to, decided once when it is
folded in and never recomputed, and the row keys on that. A lone call
that gains a neighbour becomes a group *without* changing identity,
which the old key got wrong in the other direction too -- one row was
replaced by another rather than updated.

`joinPages` hands the arriving older calls the name of the run they are
joining, rather than renaming that run after them. The obvious way round
is the wrong one: the newer half is the part already on screen, so
naming the joined run after the older half renames the row the reader is
looking at, which is the whole failure this is meant to remove.

Checked against the same twelve-`/tools 8` rig, whose page boundary falls
inside the second group: every group still reads eight, so the grouping
is unchanged -- what changed is that none of their identities move.

Toward the standing rule for this screen, which is that it may only move
when the reader is at the newest end and something new arrives.

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

@@ -93,6 +93,17 @@ sealed class TranscriptItem {
     data class ToolRun(
         override val seq: Long,
         val id: String,
+        /**
+         * The run of adjacent calls this one belongs to, named once when the call is folded in and
+         * never recomputed.
+         *
+         * Carried rather than derived because a run can gain members at *either* end -- a new call
+         * arriving beside it, or a page of history arriving in front of it -- so no function of its
+         * current members is stable. It is the first call's id at the moment the run started, which
+         * is a name rather than a description: [joinPages] hands it to older calls that turn out to
+         * belong to the same run, instead of renaming the run they joined.
+         */
+        val runId: String,
         val tool: String,
         val input: String,
         val output: String,
@@ -177,6 +188,16 @@ sealed class TranscriptItem {
     ) : TranscriptItem()
 }
 
+/**
+ * The run a call joins: the one it lands next to, or a new one named after itself.
+ *
+ * Only ever consulted when the call is first folded in. That is what makes the name stable -- a run
+ * keeps whatever it was called when it started, however many calls arrive at either end of it
+ * afterwards.
+ */
+private fun runIdFor(items: List<TranscriptItem>, id: String): String =
+    (items.lastOrNull() as? TranscriptItem.ToolRun)?.runId ?: id
+
 /**
  * Puts a page of older items in front of the ones already loaded, healing any tool call the page
  * boundary cut in two.
@@ -220,7 +241,28 @@ fun joinPages(earlier: List<TranscriptItem>, later: List<TranscriptItem>): List<
             row
         }
     }
-    return healed + later.filterNot { it is TranscriptItem.ToolRun && it.id in endedLater }
+    val kept = later.filterNot { it is TranscriptItem.ToolRun && it.id in endedLater }
+    return adoptRun(healed, kept) + kept
+}
+
+/**
+ * Hands the older calls at the join the name of the run they are joining.
+ *
+ * The two pages were folded separately, so a run split by the boundary came back as two runs with
+ * two names. Naming the joined run after the *older* half would be the obvious way round and is the
+ * wrong one: the newer half is the part already on screen, and renaming it is renaming the row the
+ * reader is looking at, which is how a list loses its anchor and steps under them. So the arriving
+ * calls take the name of the ones already there, and nothing visible changes identity.
+ */
+private fun adoptRun(
+    earlier: List<TranscriptItem>,
+    later: List<TranscriptItem>,
+): List<TranscriptItem> {
+    val joining = (later.firstOrNull() as? TranscriptItem.ToolRun)?.runId ?: return earlier
+    val tail = earlier.takeLastWhile { it is TranscriptItem.ToolRun }
+    if (tail.isEmpty()) return earlier
+    return earlier.dropLast(tail.size) +
+        tail.map { (it as TranscriptItem.ToolRun).copy(runId = joining) }
 }
 
 fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem> =
@@ -242,6 +284,7 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
                 TranscriptItem.ToolRun(
                     entry.seq,
                     event.id,
+                    runIdFor(items, event.id),
                     event.tool,
                     event.input,
                     "",
@@ -262,6 +305,7 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
                     TranscriptItem.ToolRun(
                         entry.seq,
                         event.id,
+                        runIdFor(items, event.id),
                         "tool",
                         "",
                         event.output,
@@ -896,7 +940,7 @@ fun SessionScreen(
                 // reason: the working indicator appearing and disappearing is another insertion
                 // at the same end. Paging older history is the opposite insertion and was
                 // already fine, and stays fine, because a key survives both.
-                items(rows.asReversed(), key = { it.seq }) { row ->
+                items(rows.asReversed(), key = { it.key }) { row ->
                     when (row) {
                         is TranscriptRow.Tools ->
                             ToolGroup(