Say when a session is working, and what it was told

Three things a phone could not see, all of them the same shape: the
session was doing something and nothing on screen said so.

A turn nobody here started never reported itself. `Running` was sent
where a message was *sent*, so a session picked up mid-turn, one
compacting on its own, or one another agent wrote to sat there reading
as idle until it finished. The driver now says it from what it observes
-- output that could only come from a turn in flight -- which is the
same set of events that already announced a steer, with the ends
swapped.

An imported session had it worse: nothing but replayed lines ever
reaches it, and a status was not among them, so it was permanently
whatever it was when it was adopted. Its file does not record a turn
ending, but it does record why each assistant message stopped, and
`tool_use` versus anything else answers it. A record that says nothing
leaves the status alone rather than voting for idle.

Messages from other agents were dropped outright: the CLI marks them
meta, and this replayed everything except meta. They are now a row of
their own, closed by default like a tool call, named for the session
that sent it -- not the reader's own bubble, because they did not say
it, and a session working on something this phone never asked for is
exactly what one of these explains.

Measured against a real session file rather than guessed: the peer
record carries the sender's name and the message body in `origin`,
beside a copy wrapped for the model to read.

server/src/session/mod.rs

@@ -1016,6 +1016,18 @@ async fn pump(
             Event::MessageTaken { text } => Event::UserMessage { text },
             other => other,
         };
+        // A status the session is already in is not news. Imported
+        // sessions make this the common case rather than a rarity: each
+        // sync reads the turn state off the file's newest record, and
+        // most of them find the same answer as the sync before -- which
+        // would otherwise be a transcript entry, a broadcast, and a
+        // recomposition on every phone, several times a minute, to say
+        // nothing at all.
+        if let Event::Status { state } = &event
+            && *shared.status.lock().unwrap() == *state
+        {
+            continue;
+        }
         match transcript.append(event, ts) {
             Ok(entry) => {
                 if let Event::Status { state } = &entry.event {