Never run two turns into one, and say when a session waits on its own work

A turn started by something with no row of its own -- a subagent reporting
back, a peer message the CLI only owns up to at the end -- met the previous
reply with nothing between it, and the fold grew that reply rather than
starting a new one. Two answers were drawn as one paragraph, running together
mid-sentence with not even a space between them. The fold now refuses to grow
a settled reply, and `joinPages` carries the same rule across a page boundary.

The other half is the row. `Event::TaskNote` records a background task
reporting back -- a subagent that finished, or a backgrounded command -- with
its title, how it ended and what it said; `TaskNoteRow` draws it as a card,
since somebody said this, and its own row rather than an update to the Task
call's, which is above everything the session has said since. Reported once
however many of the CLI's two lifecycle shapes arrive.

`SessionStatus::Waiting` is a session whose own turn is over while work it
started is not. `Idle` means "waiting for a person" and this means the
opposite, so reporting it as idle sent a "finished" notification at the one
moment that was untrue. Drawn as "waiting" in `waitingColor`; the queue and
the held-command boundary release on either end-of-turn status, so a message
sent while a subagent runs is not held until it finishes.

And a usage limit the account hits inside a subagent now reaches the session
as well as the subagent's transcript. `resume.rs` can only schedule against a
session, and a background Task outliving its parent's turn is the ordinary
case, so auto-resume was doing nothing at all for it.

The status word and its colour were two `when`s on two screens, and the second
missed `waiting` silently; they are `sessionStatusWord`/`sessionStatusColour`
now. Echo's `/subagent n` reproduces the whole shape, staggered a second
apart. Verified on the emulator against the sandbox: 169 server tests, ktfmt,
clippy, rustfmt, Android lint and the JVM unit tests all clean.

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

app/androidApp/src/test/kotlin/com/example/aiapp/TranscriptItemsTest.kt

@@ -0,0 +1,96 @@
+package com.example.aiapp
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Where one turn ends and the next begins, which is the part of the fold that had no way of saying
+ * anything was wrong: two replies run together read as one long answer, and the seam is somewhere
+ * in the middle of a sentence.
+ */
+class TranscriptItemsTest {
+    private var seq = 0L
+
+    private fun fold(items: List<TranscriptItem>, event: SessionEvent) =
+        foldEvent(items, SeqEvent(seq = ++seq, ts = 1.0, event = event))
+
+    private fun fold(vararg events: SessionEvent) =
+        events.fold(emptyList<TranscriptItem>()) { items, event -> fold(items, event) }
+
+    private fun texts(items: List<TranscriptItem>) =
+        items.filterIsInstance<TranscriptItem.AssistantMsg>().map { it.text }
+
+    @Test
+    fun text_after_the_turn_ended_is_a_new_reply_rather_than_more_of_the_last_one() {
+        val items =
+            fold(
+                SessionEvent.AssistantText("You'll get the one-line notice when it lands."),
+                SessionEvent.Status("idle"),
+                SessionEvent.AssistantText("Dev Updater fix is pushed."),
+            )
+        assertEquals(
+            listOf("You'll get the one-line notice when it lands.", "Dev Updater fix is pushed."),
+            texts(items),
+        )
+    }
+
+    @Test
+    fun deltas_of_one_reply_still_accumulate_into_it() {
+        val items =
+            fold(
+                SessionEvent.AssistantText("Still "),
+                SessionEvent.AssistantText("running "),
+                SessionEvent.Status("running"),
+                SessionEvent.AssistantText("its tests."),
+            )
+        assertEquals(listOf("Still running its tests."), texts(items))
+    }
+
+    @Test
+    fun a_task_reporting_back_is_a_row_between_the_two_turns() {
+        val items =
+            fold(
+                SessionEvent.AssistantText("Launched it."),
+                SessionEvent.Status("waiting"),
+                SessionEvent.TaskNote("toolu_1", "the Dev Updater agent", "completed", "pushed"),
+                SessionEvent.AssistantText("Noted."),
+            )
+        assertEquals(3, items.size, "$items")
+        assertTrue(items[1] is TranscriptItem.TaskNote, "$items")
+        assertEquals(listOf("Launched it.", "Noted."), texts(items))
+    }
+
+    /**
+     * The page-join half of the same rule. A boundary that cuts one reply leaves an unfinished half
+     * to be rejoined; a boundary that lands between two turns must not join anything, or paging
+     * back puts the run-together paragraph straight back.
+     */
+    @Test
+    fun paging_back_rejoins_a_cut_reply_and_leaves_two_finished_ones_apart() {
+        val cut =
+            joinPages(
+                listOf(TranscriptItem.AssistantMsg(1, "half a ")),
+                listOf(TranscriptItem.AssistantMsg(2, "sentence", settled = true)),
+            )
+        assertEquals(listOf("half a sentence"), texts(cut))
+
+        val whole =
+            joinPages(
+                listOf(TranscriptItem.AssistantMsg(1, "One turn.", settled = true)),
+                listOf(TranscriptItem.AssistantMsg(2, "The next.", settled = true)),
+            )
+        assertEquals(listOf("One turn.", "The next."), texts(whole))
+    }
+
+    /** The endings nobody builds a screen for -- see [taskNoteHeading]. */
+    @Test
+    fun a_task_note_says_which_ending_it_was() {
+        assertEquals("Message from helper 1", taskNoteHeading("helper 1", "completed"))
+        assertEquals("Message from a background task", taskNoteHeading(null, "completed"))
+        assertEquals("helper 1 failed", taskNoteHeading("helper 1", "failed"))
+        assertEquals("helper 1 was cancelled", taskNoteHeading("helper 1", "cancelled"))
+        // A word this build has never seen is said as itself, not mapped onto the nearest one.
+        assertEquals("helper 1: evicted", taskNoteHeading("helper 1", "evicted"))
+    }
+}