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/echo.rs

@@ -13,6 +13,8 @@
 //! - `/slow [seconds]` -- a turn that stays running (default 30), so states that only
 //!   exist *while* something is happening can be looked at.
 //! - `/error [text]` -- a failure, which is otherwise awkward to cause.
+//! - `/peer [text]` -- a message from another agent, which otherwise takes
+//!   two live sessions and one of them deciding to write.
 //!
 //! This is exactly the event vocabulary the real drivers produce, so a UI
 //! that renders echo sessions correctly renders the real thing.
@@ -36,11 +38,14 @@ use super::driver::{Driver, Event, EventSink, ImageRef, SessionStatus};
 /// stay fast.
 const DELTA_DELAY: Duration = Duration::from_millis(50);
 
-/// How long a fake compaction takes. A real one runs for a minute or two,
-/// which is too long to sit through when what is being checked is what the
-/// screen does; this is long enough that the state is visible and short
-/// enough to wait for.
-const COMPACT_TIME: Duration = Duration::from_secs(3);
+/// How long a fake compaction takes.
+///
+/// A measured one, near enough: driving a real session through `/compact`
+/// on 2026-08-29 took 13 seconds for a small conversation, and a large one
+/// takes minutes. Three seconds -- what this was -- is too short to look
+/// at the row that only exists while a compaction is running, and too
+/// short to watch its elapsed count reach two digits.
+const COMPACT_TIME: Duration = Duration::from_secs(13);
 
 pub struct EchoDriver {
     sink: EventSink,
@@ -115,6 +120,28 @@ impl Driver for EchoDriver {
             return;
         }
 
+        // Answered on the spot rather than in the turn below, because a
+        // peer message is not a turn: it is something that arrives, and
+        // what is being exercised is the row it becomes. The message that
+        // asked for it is still announced -- every driver owes exactly one
+        // `MessageTaken` per message, and a command that quietly vanishes
+        // from the transcript is the one thing echo must not model.
+        if let Some(rest) = text.strip_prefix("/peer") {
+            self.emit(Event::MessageTaken { text: text.clone() });
+            self.emit(Event::PeerMessage {
+                from: "dev-updater-f5".to_string(),
+                text: if rest.trim().is_empty() {
+                    "Pull before you touch AGENTS.md -- I pushed three commits to it \
+                     in the last hour, and origin/main has moved since you last looked.\n\n\
+                     The tree is clean as of now, but it was not for most of that time."
+                        .to_string()
+                } else {
+                    rest.trim().to_string()
+                },
+            });
+            return;
+        }
+
         if let Some(rest) = text.strip_prefix("/question") {
             let id = format!("q-{}", super::random_hex());
             let prompt = if rest.trim().is_empty() {