Keep the reader's place: in a group, in a compaction, and in the list

Five things Iris asked for, all about the transcript screen holding still
around whoever is reading it.

A tool call opened on its own stayed open when a second call in the same
run turns it into a group. Watching a Bash call and having the session
make another one used to shut the card being read and fold it behind
"Called 2 tools" -- the reader lost their place because something else
happened. The transition is noticed once, at the moment a run first
becomes a group; after that the group's own toggle owns it, so shutting a
group whose inner call is still expanded does not re-open it.

The compaction clock is taken from the `compacting` status event's own
timestamp rather than from this device noticing one, so it survives
leaving the session and coming back -- it used to disappear, because the
only thing that knew when the compaction started was a screen that had
been disposed. The server timestamps every transcript line, so this is
still a measurement; it is compared against the phone's wall clock, which
is the same comparison a session's "last active" already makes.

Session settings are a dialog over the session instead of a screen below
it. Two controls did not warrant a page transition and a back stack, and
the thing they change was hidden while they were on screen. Captions are
gone -- each control is a labelled noun -- and "Notify me" is
"Notifications" with a bell beside it (`md-bell`, added to the committed
Nerd Fonts subset). Failures keep their words, since those are what a
reader cannot work out by looking.

Tool groups are rounded like every other card, their foot bar is the same
height as their heading (both derived from the heading's own line height,
so the pair cannot drift), and the calls inside are a connected stack:
square where they face a neighbour, rounded on the outside, with a small
gap so the join reads as a join.

Scroll position is persistent on the device, per session, keyed by the
row rather than by an index -- an index means nothing across a reopen,
where the transcript is fetched newest-first. Reopening pages backwards
until that row is loaded *and* has something older behind it, because the
oldest loaded row is a half-row that grows when the page behind it
arrives; anchoring into one landed a screen and a half out. The list
draws nothing until the position lands, so there is no frame in which the
transcript is somewhere other than where it was left.

Two things found on the way. `snapshotFlow`'s first emission is the state
before anybody has touched the list, and reading it as a scroll that had
just ended at the newest end wiped every saved position on the way in.
And backwards pages now ask for 800 events rather than 80: ai-app-2
measured a real transcript at 2,426 events for seven assistant messages,
so a page of eighty is a fifth of one row and filling the lookahead took
about thirty sequential round trips -- seconds of a list that will not
move, over the tunnel.

`/tools [n] [gap]` in the echo driver takes seconds between calls, which
is what makes a run grow slowly enough for somebody to have opened one of
its calls first.

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

server/src/session/echo.rs

@@ -7,8 +7,11 @@
 //! A leading word asks for something more specific:
 //!
 //! - `/tool [input]` -- a full tool run, start through end.
-//! - `/tools [n]` -- n calls back to back, for what a run of them looks
-//!   like when a screen groups them.
+//! - `/tools [n] [gap]` -- n calls back to back, for what a run of them
+//!   looks like when a screen groups them. `gap` is seconds between one
+//!   call and the next, default none: it is what makes a run *grow* while
+//!   somebody is looking at it, which is the only way to reach the state
+//!   where a call opened on its own gains a neighbour.
 //! - `/question [text]` -- a question, exercising the answer path.
 //! - `/ask` -- an AskUserQuestion call: two questions on one tool call,
 //!   with descriptions, a preview and a multi-select, which is the shape
@@ -357,9 +360,27 @@ impl EchoDriver {
         // shorter one first would read "/tools 4" as a single tool whose
         // input is "s 4".
         let many_tools = text.strip_prefix("/tools").map(|rest| {
+            let mut words = rest.split_whitespace();
             // At least two, because one call is not a run of them and this
             // exists to produce a run.
-            rest.trim().parse::<usize>().unwrap_or(3).clamp(2, 12)
+            let count = words
+                .next()
+                .and_then(|w| w.parse().ok())
+                .unwrap_or(3usize)
+                .clamp(2, 12);
+            // How long to wait between calls, default none. A run that
+            // arrives all at once cannot exercise anything about a run
+            // *growing*: the case worth watching is a call somebody has
+            // opened and is reading when the next one turns it into a
+            // group, and 50ms apart is faster than anybody can open one.
+            let gap = Duration::from_secs(
+                words
+                    .next()
+                    .and_then(|w| w.parse().ok())
+                    .unwrap_or(0u64)
+                    .clamp(0, 30),
+            );
+            (count, gap)
         });
         let run_tool = if many_tools.is_some() {
             None
@@ -437,8 +458,11 @@ impl EchoDriver {
                 return;
             }
 
-            if let Some(count) = many_tools {
+            if let Some((count, gap)) = many_tools {
                 for i in 1..=count {
+                    if i > 1 {
+                        tokio::time::sleep(gap).await;
+                    }
                     let id = format!("t-{}", super::random_hex());
                     send(Event::ToolStart {
                         id: id.clone(),