Take subagent reports out of the main transcript, and separate turns with a rule

A row per finished background task is a screenful of dividers about work the
reader was not asking after, and one of them turned out to be a whole shell
command drawn as centred prose, because its words came from somewhere with no
reason to keep them short. `Event::TaskNote` is gone entirely, along with the
row that drew it. A subagent's closing report is recorded as that subagent's
own transcript's closing text and is read in the subcard, which is where it
was already going; what the parent gets a row for is a message a subagent
genuinely sends it, which arrives by the peer path and has had one all along.

What remains is the actual defect and the smallest thing that fixes it. The
fold still refuses to grow a settled reply, so a turn boundary is always a
message boundary, and where two replies then abut it puts a `TurnBreak`
between them: a hairline, no words, no colour. Made by the fold rather than
sent by the server, because it is not something that happened -- it is the
boundary between two things that did. `joinPages` puts one in at a page seam,
which the fold never gets to see.

The task notification is still what closes a task in `Status::Waiting`'s
bookkeeping, and the registry lookup that recognises one this translator never
saw start is what makes that work for a session adopted across a restart.

Verified on the emulator: three replies, three rules, and nothing about the
helpers anywhere in the parent. 170 server tests, 85 JVM tests, ktfmt, clippy,
rustfmt and Android lint clean.

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

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

@@ -144,24 +144,27 @@ sealed class TranscriptItem {
     }
 
     /**
-     * A task the session started in the background reporting back: a subagent that finished, or a
-     * backgrounded command.
+     * Where one turn ended and the next began with nothing said in between.
      *
-     * Its own row rather than an update to the Task call's, which is wherever the call was made --
-     * above everything the session has said since, where a reader at the bottom would never see it
-     * change. Here it is where it arrived, in front of the turn it caused.
+     * A rule and no words. Two replies meet like this whenever a turn starts without anybody typing
+     * -- a subagent reporting back, a session the CLI picked up by itself -- and drawn with only
+     * the ordinary gap between them they read as one answer with a paragraph break through the
+     * middle of it. What the reader needs is to see that these are two; what started the turn is
+     * somebody else's transcript's business, and a row per background task is a screenful of
+     * dividers about work nobody was asking after.
+     *
+     * Made by the fold rather than sent by the server, because it is not something that happened:
+     * it is the boundary between two things that did. See [foldEvent].
      */
-    data class TaskNote(
-        override val seq: Long,
-        /** The tool call it belongs to; a subagent is named by that id. */
-        val about: String,
+    data class TurnBreak(override val seq: Long) : TranscriptItem() {
         /**
-         * The subagent's title, or null for a backgrounded command -- see [SessionEvent.TaskNote].
+         * Its own key, because it shares a [seq] with the reply it sits above -- that reply's first
+         * delta is the event this was made at, and a keyed list refuses two items with one key by
+         * taking the app down.
          */
-        val title: String?,
-        val status: String,
-        val summary: String?,
-    ) : TranscriptItem()
+        override val key: Any
+            get() = "break$seq"
+    }
 
     /**
      * A command the session ran on itself -- `/compact`, `/rename`. Kept in the transcript rather
@@ -302,7 +305,9 @@ private fun healSplitMessage(
     // A settled reply is a whole turn, so the two are two answers that happen to meet at the
     // boundary rather than one cut in half -- the same distinction the fold makes, and joining them
     // here would put back exactly the run-together paragraph it stops.
-    if (head.settled) return earlier to later
+    // The rule between them is put in here too, since the fold that would have made it never saw
+    // these two side by side.
+    if (head.settled) return earlier to (listOf(TranscriptItem.TurnBreak(tail.seq)) + later)
     return earlier.dropLast(1) to (listOf(tail.copy(text = head.text + tail.text)) + later.drop(1))
 }
 
@@ -397,7 +402,13 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
             if (last is TranscriptItem.AssistantMsg && !last.settled) {
                 items.dropLast(1) + last.copy(text = last.text + event.delta)
             } else {
-                items + TranscriptItem.AssistantMsg(entry.seq, event.delta)
+                // A rule between the two, and only where they actually meet: anything that draws a
+                // row of its own -- a message, a command, a peer note -- is already the boundary.
+                val between =
+                    if (last is TranscriptItem.AssistantMsg)
+                        listOf(TranscriptItem.TurnBreak(entry.seq))
+                    else emptyList()
+                items + between + TranscriptItem.AssistantMsg(entry.seq, event.delta)
             }
         }
         is SessionEvent.ToolStart ->
@@ -475,15 +486,6 @@ fun foldEvent(items: List<TranscriptItem>, entry: SeqEvent): List<TranscriptItem
                 }
             }
         is SessionEvent.PeerMessage -> placePeerNote(items, entry.seq, event)
-        is SessionEvent.TaskNote ->
-            items +
-                TranscriptItem.TaskNote(
-                    entry.seq,
-                    event.about,
-                    event.title,
-                    event.status,
-                    event.summary,
-                )
         is SessionEvent.CommandSent -> items + TranscriptItem.CommandRow(entry.seq, event.text)
         // Screen-level state, not transcript rows -- see SessionScreen.
         is SessionEvent.CommandQueued -> items