diff --git a/crates/ai-host/src/contained.rs b/crates/ai-host/src/contained.rs
index e14d7a91..edc7c931 100644
--- a/crates/ai-host/src/contained.rs
+++ b/crates/ai-host/src/contained.rs
@@ -147,6 +147,12 @@ pub fn prepare(app_id: &str) -> Result<(), String> {
     service.prepare()
 }
 
+/// The kernel's slug of `app_id`'s peer, once one is live and bound (what
+/// `peer_list` shows and `peer_send_input` takes).
+pub fn peer_slug(app_id: &str) -> Option<String> {
+    live(|l| l.get(app_id).cloned())?.peer_slug()
+}
+
 /// Whether `app_id` has a live peer (prepared, or opened by the app).
 pub fn is_live(app_id: &str) -> bool {
     live(|l| l.contains_key(app_id))
diff --git a/crates/app-peers/src/broker.rs b/crates/app-peers/src/broker.rs
index a06ba181..83b266a6 100644
--- a/crates/app-peers/src/broker.rs
+++ b/crates/app-peers/src/broker.rs
@@ -441,6 +441,66 @@ impl State {
     }
 }
 
+/// The words that started one turn of the app's conversation, as this
+/// broker sent them: which session (lane), who spoke and when it started.
+#[derive(Clone, Debug)]
+struct Request {
+    turn: String,
+    session: String,
+    lane: &'static str,
+    text: String,
+    speaker: Speaker,
+    /// RFC 3339 (UTC), the host's clock at the start.
+    at: String,
+}
+
+impl Request {
+    fn to_json(&self) -> Value {
+        json!({"text": self.text, "speaker": self.speaker.to_json()})
+    }
+}
+
+impl State {
+    fn note_request(&mut self, request: Request) {
+        if request.text.trim().is_empty() || self.requests.iter().any(|r| r.turn == request.turn) {
+            return;
+        }
+        self.requests.push_back(request);
+        while self.requests.len() > REMEMBERED {
+            self.requests.pop_front();
+        }
+    }
+
+    fn request_of(&self, turn: &str) -> Option<&Request> {
+        self.requests.iter().find(|r| r.turn == turn)
+    }
+}
+
+/// Now as RFC 3339 in UTC with microseconds, like the kernel's
+/// `persisted_at` (so [`time_key`] orders both).
+fn rfc3339_now() -> String {
+    let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
+    let secs = now.as_secs() as i64;
+    let (days, rem) = (secs.div_euclid(86_400), secs.rem_euclid(86_400));
+    // Days since 1970-01-01 to a civil date (H. Hinnant's algorithm).
+    let z = days + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z - era * 146_097;
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let day = doy - (153 * mp + 2) / 5 + 1;
+    let month = if mp < 10 { mp + 3 } else { mp - 9 };
+    let year = yoe + era * 400 + i64::from(month <= 2);
+    format!(
+        "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}.{:06}Z",
+        rem / 3600,
+        rem % 3600 / 60,
+        rem % 60,
+        now.subsec_micros()
+    )
+}
+
 fn remember(list: &mut VecDeque<String>, item: String) {
     if !list.contains(&item) {
         list.push_back(item);
@@ -501,6 +561,12 @@ struct State {
     /// Who speaks in each person-lane turn this broker started (the origin
     /// it sent), by turn id.
     speakers: HashMap<String, Speaker>,
+    /// The words that started each turn of the app's conversation this
+    /// broker started (a person's message, the system agent's input), in
+    /// start order. The kernel records a turn's user message only when the
+    /// turn ends (and never for an interrupted one), so a follower is told
+    /// them when the turn starts, and history keeps a stopped turn's.
+    requests: VecDeque<Request>,
     /// The system agent's inputs waiting for the peer's running turn, in
     /// order (one queue per peer; the person's lane has its own session).
     queue: VecDeque<PeerInput>,
@@ -568,6 +634,7 @@ impl Broker {
                 turn_triggers: HashMap::new(),
                 trigger_order: VecDeque::new(),
                 speakers: HashMap::new(),
+                requests: VecDeque::new(),
                 queue: VecDeque::new(),
                 conversations: 0,
                 cwds: HashMap::new(),
@@ -1626,6 +1693,14 @@ impl Inner {
             let mut st = self.lock();
             st.peer_turn = Some(input.turn_id.clone());
             remember(&mut st.input_turns, input.turn_id.clone());
+            st.note_request(Request {
+                turn: input.turn_id.clone(),
+                session: input.session_id.clone(),
+                lane: LANE_SYSTEM_AGENT,
+                text: input.text.clone(),
+                speaker: Speaker { kind: host_tools::TurnOrigin::SystemAgent, label: None },
+                at: rfc3339_now(),
+            });
         }
         let inner = self.clone();
         self.rt().spawn(async move {
@@ -2135,8 +2210,11 @@ fn time_key(row: &Value) -> Option<String> {
 /// (its sharing context's transcript) and the system agent's lane (the
 /// peer's), each row with its `lane` and, for a marked user message, its
 /// `speaker` and `display_text`, merged by `persisted_at` (a row without one
-/// keeps its place in its own lane's order).
-fn merged_history(person: Value, system_agent: Value) -> Value {
+/// keeps its place in its own lane's order). A turn this broker started
+/// whose user message the kernel never recorded (it was stopped) gets its
+/// request as a user row (`requests`: this conversation's lanes), at the
+/// time it started.
+fn merged_history(person: Value, system_agent: Value, requests: &[Request]) -> Value {
     let mut out = speakers_in_history(person);
     let lane_rows = |history: Value, lane: &str| -> Vec<Value> {
         let mut rows = match speakers_in_history(history)["messages"].take() {
@@ -2150,6 +2228,22 @@ fn merged_history(person: Value, system_agent: Value) -> Value {
     };
     let mut rows = lane_rows(json!({"messages": out["messages"].take()}), LANE_PERSON);
     rows.extend(lane_rows(system_agent, LANE_SYSTEM_AGENT));
+    for request in requests {
+        let recorded = rows.iter().any(|row| {
+            row["role"] == "user"
+                && row["lane"] == request.lane
+                && (row["turn_id"] == request.turn.as_str()
+                    || row["thread_id"] == request.turn.as_str()
+                    || row["display_text"].as_str().or_else(|| row["content"].as_str()).is_some_and(|t| t.trim() == request.text.trim()))
+        });
+        if !recorded {
+            rows.push(json!({
+                "role": "user", "content": request.text, "display_text": request.text,
+                "speaker": request.speaker.to_json(), "lane": request.lane,
+                "turn_id": request.turn, "persisted_at": request.at, "unrecorded": true,
+            }));
+        }
+    }
     // A stable sort: equal or missing times keep their lane order.
     let mut last = String::new();
     let mut keyed: Vec<(String, Value)> = Vec::with_capacity(rows.len());
@@ -2373,6 +2467,13 @@ impl ContextInner {
             if let Some(speaker) = speaker {
                 data["speaker"] = speaker.to_json();
             }
+            // The turn's words, when it starts: the kernel sends its user
+            // message only when the turn ends (never for a stopped one).
+            if method == "turn/started" {
+                if let Some(request) = turn_id.and_then(|t| inner.lock().request_of(t).map(Request::to_json)) {
+                    data["request"] = request;
+                }
+            }
         }
         // A conversation's caller hears only its own turn; a request
         // context's session is its caller's alone.
@@ -2512,6 +2613,14 @@ impl ContextInner {
             let mut st = inner.lock();
             st.note_trigger(&turn_id, trigger);
             st.speakers.insert(turn_id.clone(), speaker.clone());
+            st.note_request(Request {
+                turn: turn_id.clone(),
+                session: session.to_owned(),
+                lane: LANE_PERSON,
+                text: text.clone(),
+                speaker: speaker.clone(),
+                at: rfc3339_now(),
+            });
         }
         let params = json!({
             "session_id": session,
@@ -2603,11 +2712,12 @@ impl ContextInner {
                 if self.conversation {
                     // Both lanes: the person's context and the peer's session.
                     let peer_session = inner.lock().peer.as_ref().map(|(_, p)| p.session.clone());
-                    let system_agent = match peer_session {
+                    let system_agent = match peer_session.clone() {
                         Some(peer) => inner.request("session/hydrate", json!({"session_id": peer, "include": ["messages"]})).await?,
                         None => json!({"messages": []}),
                     };
-                    history.map(|person| merged_history(person, system_agent))
+                    let requests: Vec<Request> = inner.lock().requests.iter().filter(|r| r.session == session || peer_session.as_deref() == Some(r.session.as_str())).cloned().collect();
+                    history.map(|person| merged_history(person, system_agent, &requests))
                 } else {
                     history
                 }
@@ -2807,6 +2917,10 @@ impl OctosAppService for Broker {
         self.bind()
     }
 
+    fn peer_slug(&self) -> Option<String> {
+        self.peer().map(|(slug, _)| slug)
+    }
+
     fn model(&self) -> Option<ModelInfo> {
         self.0.lock().model.clone()
     }
diff --git a/crates/app-peers/src/contract.rs b/crates/app-peers/src/contract.rs
index aae35e8d..26bcb47e 100644
--- a/crates/app-peers/src/contract.rs
+++ b/crates/app-peers/src/contract.rs
@@ -314,6 +314,13 @@ pub trait OctosAppService: Send + Sync {
     fn prepare(&self) -> Result<(), String> {
         Ok(())
     }
+    /// The kernel's slug of the app's peer once it is bound (what the
+    /// system agent's `peer_list` shows and `peer_send_input` takes, e.g.
+    /// `os-news-22a12f90`: never the app id). `None` before, or for a
+    /// service without a peer of its own.
+    fn peer_slug(&self) -> Option<String> {
+        None
+    }
     /// The app is closing: close every context and release subscriptions.
     /// Does not stop a shared kernel or other apps' work.
     fn release(&self);
diff --git a/crates/app-peers/tests/broker.rs b/crates/app-peers/tests/broker.rs
index b53f6484..be873028 100644
--- a/crates/app-peers/tests/broker.rs
+++ b/crates/app-peers/tests/broker.rs
@@ -1330,6 +1330,10 @@ fn a_conversation_follows_both_lanes_and_merges_their_history() {
     assert!(sa.iter().all(|d| d["speaker"]["kind"] == "system_agent" && d["lane"] == "system_agent"), "{sa:?}");
     let user = sa.iter().find(|d| d["method"] == "projection/envelope").unwrap();
     assert_eq!(user["display_text"], "check the inbox");
+    // The kernel sends a turn's user message when the turn ends: its words
+    // come with its start, from what the broker sent.
+    let started = sa.iter().find(|d| d["method"] == "turn/started").unwrap();
+    assert_eq!(started["request"], json!({"text": "check the inbox", "speaker": {"kind": "system_agent"}}));
     // The person's own message: the follower sees it too, in the person's
     // lane, with its speaker.
     let (sink, rx) = collect();
@@ -1340,6 +1344,10 @@ fn a_conversation_follows_both_lanes_and_merges_their_history() {
         seen.iter().any(|d| d["method"] == "turn/completed" && d["speaker"]["kind"] == "person" && d["speaker"]["label"] == "Rinx" && d["lane"] == "person" && d["params"]["session_id"] == lane.as_str()),
         "{seen:?}"
     );
+    assert!(
+        seen.iter().any(|d| d["method"] == "turn/started" && d["lane"] == "person" && d["request"] == json!({"text": "thanks", "speaker": {"kind": "person", "label": "Rinx"}})),
+        "{seen:?}"
+    );
     // A caller's sink hears only its own turn: nothing of the system agent's.
     let (sink, rx) = collect();
     chat.call(ContextOp::History, sink).unwrap();
@@ -1396,6 +1404,47 @@ fn a_conversation_follows_both_lanes_and_merges_their_history() {
     drop(broker);
 }
 
+/// A stopped turn's user message is never recorded by the kernel (it
+/// writes a turn's rows when the turn ends): the conversation's history
+/// keeps its request from the broker, in its lane, at the time it started;
+/// a recorded one is not repeated.
+#[test]
+fn a_stopped_turns_request_stays_in_the_conversations_history() {
+    let host = Arc::new(RecordingHost::default());
+    let (broker, script) = new_broker_with(&ALL, Some(host), None);
+    {
+        let mut s = script.lock().unwrap();
+        s.hold_turns = true;
+        s.interrupts_end = true;
+    }
+    broker.set_account(Some("@a:x"));
+    let chat = broker.open_conversation(spec("@a:x", "ui", &ALL)).unwrap();
+    let (sink, rx) = collect();
+    chat.call(ContextOp::TurnFrom { text: "a long digest please".into(), trigger: TurnTrigger::Person }, sink).unwrap();
+    wait_for("the person's turn", || calls_of(&script, "turn/start").len() == 1);
+    let (sink, stop_rx) = collect();
+    chat.call(ContextOp::Interrupt, sink).unwrap();
+    assert_eq!(complete(&stop_rx).unwrap()["turns"][0]["lane"], "person");
+    assert!(complete(&rx).is_err(), "the stopped turn ends with its error");
+    {
+        let mut s = script.lock().unwrap();
+        s.history = vec![json!({"role": "user", "content": "[from the person: Rinx] earlier", "persisted_at": "2020-01-01T00:00:00Z"})];
+        s.peer_history = vec![];
+    }
+    let (sink, rx) = collect();
+    chat.call(ContextOp::History, sink).unwrap();
+    let rows = complete(&rx).unwrap()["messages"].as_array().unwrap().clone();
+    let shown: Vec<(String, String)> = rows.iter().map(|r| (r["lane"].as_str().unwrap().to_owned(), r["display_text"].as_str().unwrap_or("").to_owned())).collect();
+    assert_eq!(shown, [("person".to_owned(), "earlier".to_owned()), ("person".to_owned(), "a long digest please".to_owned())]);
+    assert_eq!(rows[1]["speaker"], json!({"kind": "person", "label": "Rinx"}));
+    // Once the kernel has the row, it is not added twice.
+    script.lock().unwrap().history.push(json!({"role": "user", "content": "[from the person: Rinx] a long digest please", "persisted_at": "2020-01-01T00:00:01Z"}));
+    let (sink, rx) = collect();
+    chat.call(ContextOp::History, sink).unwrap();
+    assert_eq!(complete(&rx).unwrap()["messages"].as_array().unwrap().len(), 2);
+    drop(broker);
+}
+
 /// A kernel that ignores `share_history` would give the person a plain
 /// context the system agent never sees: the conversation is refused.
 #[test]
diff --git a/crates/app-peers/tests/real_kernel.rs b/crates/app-peers/tests/real_kernel.rs
index a59026ca..1ac0c3ea 100644
--- a/crates/app-peers/tests/real_kernel.rs
+++ b/crates/app-peers/tests/real_kernel.rs
@@ -984,14 +984,28 @@ fn the_person_and_the_system_agent_talk_in_parallel_lanes_that_share_history() {
     assert_eq!(answer["lane"], "person");
     assert!(answer["text"].as_str().unwrap().contains("hello from the app"), "{answer}");
 
-    // The system agent's input to the same peer, in its own lane.
+    // The system agent's input to the same peer, in its own lane. The
+    // system session may still be busy with the previous turn: after its
+    // `peer_send_input` it finishes its own answer, and the kernel may wake
+    // it with the peer's result. The test is the system chat here, so it
+    // waits for its session like the chat does (the kernel queues nothing:
+    // `turn_in_progress`).
     let system_turn = |text: String| {
-        rinx.host_request(
-            "turn/start",
-            json!({"session_id": "_main:api:octosense#system", "turn_id": uuid_like(),
-                   "input": [{"kind": "text", "text": text}]}),
-        )
-        .expect("system turn");
+        let params = json!({"session_id": "_main:api:octosense#system", "turn_id": uuid_like(),
+                            "input": [{"kind": "text", "text": text}]});
+        for _ in 0..120 {
+            match rinx.host_request("turn/start", params.clone()) {
+                Err(e) if e.contains("turn_in_progress") => {
+                    eprintln!("the system session is still busy: {e}");
+                    std::thread::sleep(Duration::from_millis(500));
+                }
+                other => {
+                    other.expect("system turn");
+                    return;
+                }
+            }
+        }
+        panic!("the system session stayed busy for a minute");
     };
     let history_until = |done: &dyn Fn(&[Value]) -> bool| -> Vec<Value> {
         let mut rows = Vec::new();
diff --git a/crates/shell/src/agents.rs b/crates/shell/src/agents.rs
index 084f8339..2b8333fe 100644
--- a/crates/shell/src/agents.rs
+++ b/crates/shell/src/agents.rs
@@ -250,9 +250,42 @@ pub fn ask(app: &AgentApp) -> Access {
 
 // ------------------------------------------------------------ the system agent
 
+/// The kernel's slug of `app`'s peer, once it is bound: what the system
+/// agent's `peer_list` shows and `peer_send_input` takes (`os-news-22a12f90`,
+/// never the app id `os.news`).
+pub fn peer_slug(app: &AgentApp) -> Option<String> {
+    if !app.native {
+        return crate::ai_host::contained::peer_slug(&app.id);
+    }
+    native_slug(&app.id)
+}
+
+#[cfg(kernel)]
+fn native_slug(app: &str) -> Option<String> {
+    crate::ai_host::app_peers::broker::live(app)?.peer().map(|(slug, _)| slug)
+}
+
+#[cfg(not(kernel))]
+fn native_slug(_app: &str) -> Option<String> {
+    None
+}
+
+/// How the system agent reaches an allowed app's agent: by its peer slug
+/// with `peer_send_input`, never by the app id.
+fn reach(app: &AgentApp, slug: Option<&str>) -> String {
+    match slug {
+        Some(slug) => format!("Reach it with peer_send_input and the peer slug \"{slug}\" (not the app id {})", app.id),
+        None => format!(
+            "Find its peer slug with peer_list (the peer named \"{} \u{2026}\"), then use that slug with peer_send_input (not the app id {})",
+            peer_label(app),
+            app.id
+        ),
+    }
+}
+
 /// One app's line for the system agent: its name, its peer and where it
 /// stands, and what to do.
-fn line(app: &AgentApp) -> Value {
+pub(crate) fn line(app: &AgentApp) -> Value {
     let access = access(&app.id);
     let peer = match (access, prepared(&app.id)) {
         (Access::Allowed, Some(Prepared::Ready)) => "ready: in peer_list".to_string(),
@@ -262,12 +295,13 @@ fn line(app: &AgentApp) -> Value {
         (Access::Allowed, None) => "not started yet".to_string(),
         _ => "none".to_string(),
     };
+    let slug = if access == Access::Allowed { peer_slug(app) } else { None };
     let what = match access {
-        Access::Allowed => format!("Reach it with peer_send_input (its peer is named \"{} …\" in peer_list).", peer_label(app)),
+        Access::Allowed => format!("{}.", reach(app, slug.as_deref())),
         Access::NotAsked => format!("{}'s assistant is not yet allowed. Call agents.ask to ask the person, or tell them to open {} and use Ask {}.", app.name, app.name, app.name),
         Access::Off => format!("{}'s assistant is off. Only the person can turn it on (Settings › Assistant › Approvals); tell them.", app.name),
     };
-    json!({"app": app.id, "name": app.name, "access": access.as_str(), "peer": peer, "what_to_do": what})
+    json!({"app": app.id, "name": app.name, "access": access.as_str(), "peer": peer, "peer_slug": slug, "what_to_do": what})
 }
 
 /// The name the kernel gives the app's peer (`<label> <account tag>`): the
@@ -286,6 +320,17 @@ pub fn list() -> Value {
     json!({"apps": all().iter().map(line).collect::<Vec<_>>()})
 }
 
+/// One app's part of [`system_note`]: its name, its id and where it
+/// stands, with its peer slug once allowed and bound.
+pub(crate) fn note_part(app: &AgentApp) -> String {
+    let state = match access(&app.id) {
+        Access::Allowed => format!("allowed (in peer_list; {})", reach(app, peer_slug(app).as_deref())),
+        Access::NotAsked => "not yet allowed (not in peer_list; say so, and call agents.ask or ask the person to allow it)".to_string(),
+        Access::Off => "off (not in peer_list; only the person can turn it on in Settings)".to_string(),
+    };
+    format!("{} [{}]: {state}", app.name, app.id)
+}
+
 /// The note the system chat sends with a turn when the apps' agents
 /// changed since it last told the system agent (`None`: nothing to say).
 /// One line per app: its name and where it stands.
@@ -294,16 +339,8 @@ pub fn system_note() -> Option<String> {
     if apps.is_empty() {
         return None;
     }
-    let mut parts = Vec::new();
-    for app in &apps {
-        let state = match access(&app.id) {
-            Access::Allowed => "allowed (its agent is in peer_list; reach it with peer_send_input)".to_string(),
-            Access::NotAsked => "not yet allowed (not in peer_list; say so, and call agents.ask or ask the person to allow it)".to_string(),
-            Access::Off => "off (not in peer_list; only the person can turn it on in Settings)".to_string(),
-        };
-        parts.push(format!("{} [{}]: {state}", app.name, app.id));
-    }
-    Some(format!("[OctoSense: apps with an agent: {}. Never guess a peer that peer_list does not show.]", parts.join("; ")))
+    let parts: Vec<String> = apps.iter().map(note_part).collect();
+    Some(format!("[OctoSense: apps with an agent: {}. peer_send_input takes a peer slug from peer_list, never an app id; never guess a peer that peer_list does not show.]", parts.join("; ")))
 }
 
 /// Strip [`system_note`] from a message's text (the transcript keeps it; the
@@ -324,7 +361,7 @@ pub fn declarations() -> Vec<Value> {
         json!({
             "name": LIST_TOOL,
             "app": OWNER,
-            "description": "List every app on this device that has an agent, whether the person allowed it, and whether its peer is ready (in peer_list). Use it before delegating to an app's agent, and when peer_list does not show the app you need.",
+            "description": "List every app on this device that has an agent, whether the person allowed it, whether its peer is ready (in peer_list), and its peer slug (`peer_slug`: pass it to peer_send_input; the app id is not a peer). Use it before delegating to an app's agent, and when peer_list does not show the app you need.",
             "input_schema": {"type": "object", "properties": {}, "additionalProperties": false},
             "risk": "read",
         }),
@@ -356,14 +393,14 @@ pub fn call(tool: &str, args: &Value) -> ToolOutcome {
             };
             let now = ask(&app);
             let text = match now {
-                Access::Allowed => format!("{}'s assistant is allowed. Its peer is being prepared; it shows in peer_list shortly.", app.name),
+                Access::Allowed => format!("{}'s assistant is allowed. Its peer is being prepared; it shows in peer_list shortly (use its peer slug from peer_list or agents.list with peer_send_input, not the app id).", app.name),
                 Access::NotAsked => format!("{}'s assistant is not yet allowed: the person was asked on the first-use sheet. Wait for them; its peer shows in peer_list once they allow it.", app.name),
                 Access::Off => format!("{}'s assistant is off. Only the person can turn it on (Settings › Assistant › Approvals).", app.name),
             };
             if now == Access::Allowed {
                 prepare(&app);
             }
-            ToolOutcome::Ok(json!({"app": app.id, "name": app.name, "access": now.as_str(), "text": text}))
+            ToolOutcome::Ok(json!({"app": app.id, "name": app.name, "access": now.as_str(), "peer_slug": peer_slug(&app), "text": text}))
         }
         other => ToolOutcome::error("unknown_tool", format!("{other} is not an agents tool")),
     }
diff --git a/crates/shell/src/app_chat/mod.rs b/crates/shell/src/app_chat/mod.rs
index 1e79957c..2818ab30 100644
--- a/crates/shell/src/app_chat/mod.rs
+++ b/crates/shell/src/app_chat/mod.rs
@@ -325,14 +325,21 @@ pub fn send(text: &str) {
         return;
     };
     let failed = shared.clone();
-    let sink: EventSink = Arc::new(move |event| {
-        if let ContextEvent::Complete(Err(e)) = event {
+    // Once the turn started, its own end says how it ended (the follower's
+    // `turn_terminal`: "turn interrupted by client" after a Stop); the
+    // send's error is the same news. Only an error before any event of the
+    // turn (it never started) is the send's to tell.
+    let started = std::sync::atomic::AtomicBool::new(false);
+    let sink: EventSink = Arc::new(move |event| match event {
+        ContextEvent::Data(_) => started.store(true, std::sync::atomic::Ordering::Relaxed),
+        ContextEvent::Complete(Err(e)) if !started.load(std::sync::atomic::Ordering::Relaxed) => {
             let mut s = lock(&failed);
             if s.epoch == epoch {
                 s.conversation.notice(e);
                 changed(&mut s);
             }
         }
+        ContextEvent::Complete(_) => {}
     });
     if let Err(e) = context.call(ContextOp::TurnFrom { text, trigger: TurnTrigger::Person }, sink) {
         let mut s = lock(&shared);
diff --git a/crates/shell/src/app_chat/model.rs b/crates/shell/src/app_chat/model.rs
index 75039037..909e0bf3 100644
--- a/crates/shell/src/app_chat/model.rs
+++ b/crates/shell/src/app_chat/model.rs
@@ -16,8 +16,16 @@
 //!   and in the system agent's lane "<App>'s agent, to the system agent".
 //! - **Approvals** are the shell's: the router draws the sheet (the broker
 //!   hands every approval of the peer to it). Nothing here answers one.
+//! - **Order.** Each lane has its own ledger (`cursor.seq` counts per
+//!   session), so seqs of two lanes do not compare. Within a lane items
+//!   keep ledger order; across lanes they go by one clock, the order
+//!   events reached the panel (a stream event carries no time of its own;
+//!   history rows come merged by `persisted_at`). A turn's request line
+//!   stands where the turn STARTED: the kernel sends a turn's user message
+//!   only when the turn ends (never for a stopped one), so the broker hands
+//!   its words over with `turn/started` (`request`).
 
-use std::collections::{BTreeSet, HashMap};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 
 use serde_json::Value;
 
@@ -39,8 +47,19 @@ pub struct Conversation {
     lanes: HashMap<String, String>,
     /// Turns that ended (their late envelopes do not make them run again).
     finished: Vec<String>,
+    /// Each lane's ledger positions (`cursor.seq`) and the place on the
+    /// panel's clock each was given.
+    places: HashMap<String, BTreeMap<u64, u64>>,
+    /// Where each turn started on the panel's clock.
+    starts: HashMap<String, u64>,
+    /// The panel's clock: one tick per event, [`SPACING`] apart.
+    clock: u64,
 }
 
+/// Room between two ticks of the clock, for envelopes that arrive after a
+/// later one of their own lane.
+const SPACING: u64 = 1 << 20;
+
 impl Conversation {
     pub fn new(app: &str) -> Self {
         Conversation { app: app.to_string(), chat: ChatModel::new(), ..Conversation::default() }
@@ -70,37 +89,93 @@ impl Conversation {
         }
     }
 
+    fn tick(&mut self) -> u64 {
+        self.clock += SPACING;
+        self.clock
+    }
+
+    /// The place of `lane`'s ledger position `seq` on the panel's clock:
+    /// now, unless a later position of the same lane already came (then
+    /// just before it, after the one before it).
+    fn place(&mut self, lane: &str, seq: u64) -> u64 {
+        if let Some(at) = self.places.get(lane).and_then(|p| p.get(&seq)) {
+            return *at;
+        }
+        let now = self.tick();
+        let placed = self.places.entry(lane.to_string()).or_default();
+        let at = match placed.range(seq + 1..).next().map(|(_, at)| *at) {
+            None => now,
+            Some(next) => {
+                let before = placed.range(..seq).next_back().map(|(_, at)| *at).unwrap_or(next.saturating_sub(SPACING));
+                before + (next - before) / 2
+            }
+        };
+        placed.insert(seq, at);
+        at
+    }
+
+    /// Where `turn` started on the panel's clock (its first event, if its
+    /// start was not seen).
+    fn start_of(&mut self, turn: &str) -> u64 {
+        if let Some(at) = self.starts.get(turn) {
+            return *at;
+        }
+        let at = self.tick();
+        self.starts.insert(turn.to_string(), at);
+        at
+    }
+
+    /// The turn's request line (who asked, and what), where the turn
+    /// started; once.
+    fn request_line(&mut self, turn: &str, text: String, speaker: &Value) {
+        let known = self.chat.items.iter().any(|i| matches!(i, Item::Message { role: Role::User, turn: Some(t), .. } if t == turn));
+        if known || text.trim().is_empty() {
+            return;
+        }
+        let at = self.start_of(turn);
+        let speaker = self.speaker_label(speaker);
+        let item = Item::Message { role: Role::User, text, turn: Some(turn.to_string()), segment: None, seq: Some(at), speaker: Some(speaker) };
+        self.chat.insert_ordered(item, Some(at));
+    }
+
     /// One event of the conversation's follower: `{method, params, lane,
-    /// speaker?, display_text?}`.
+    /// speaker?, display_text?, request?}`.
     pub fn apply(&mut self, data: &Value) {
         let method = data["method"].as_str().unwrap_or("");
-        let params = &data["params"];
         let lane = data["lane"].as_str().unwrap_or(LANE_PERSON).to_string();
+        let mut params = data["params"].clone();
         let turn = params["turn_id"].as_str().unwrap_or("").to_string();
         if !turn.is_empty() {
             self.lanes.entry(turn.clone()).or_insert_with(|| lane.clone());
+            self.start_of(&turn);
         }
-        let kind = params["payload"]["type"].as_str().unwrap_or("");
-        match (method, kind) {
+        // One clock for both lanes: the model below orders by this place.
+        if method == "projection/envelope" {
+            if let Some(seq) = params["cursor"]["seq"].as_u64().or_else(|| params["seq"].as_u64()) {
+                let at = self.place(&lane, seq);
+                params["cursor"] = serde_json::json!({"seq": at});
+            }
+        }
+        let kind = params["payload"]["type"].as_str().unwrap_or("").to_string();
+        match (method, kind.as_str()) {
             ("projection/envelope", "user_message") => {
-                // Who asked: the turn starts here, in its lane.
+                // Who asked: shown where the turn started, not where the
+                // kernel recorded it (at its end).
                 let text = data["display_text"]
                     .as_str()
                     .map(str::to_string)
                     .or_else(|| params["payload"]["data"]["text"].as_str().map(|t| strip_marker(t).to_string()))
                     .unwrap_or_default();
-                let speaker = self.speaker_label(&data["speaker"]);
-                let seq = params["cursor"]["seq"].as_u64().or_else(|| params["seq"].as_u64());
-                let known = self.chat.items.iter().any(|i| matches!(i, Item::Message { role: Role::User, turn: Some(t), .. } if *t == turn));
-                if !known && !text.trim().is_empty() {
-                    let item = Item::Message { role: Role::User, text, turn: Some(turn.clone()), segment: None, seq, speaker: Some(speaker) };
-                    self.chat.insert_ordered(item, seq);
-                }
+                self.request_line(&turn, text, &data["speaker"]);
                 if !self.ended(&turn) {
                     self.running.insert(turn.clone());
                 }
             }
             ("turn/started", _) => {
+                if let Some(text) = data["request"]["text"].as_str() {
+                    let speaker = if data["request"]["speaker"].is_object() { &data["request"]["speaker"] } else { &data["speaker"] };
+                    self.request_line(&turn, text.to_string(), speaker);
+                }
                 if !self.ended(&turn) {
                     self.running.insert(turn.clone());
                 }
@@ -110,7 +185,7 @@ impl Conversation {
         let terminal = matches!(method, "turn/completed" | "turn/error") || kind == "turn_terminal";
         // The approvals the model notes are the router's; its effects are
         // never acted on here.
-        let _ = self.chat.apply(method, params);
+        let _ = self.chat.apply(method, &params);
         if terminal && !turn.is_empty() {
             self.running.remove(&turn);
             self.finished.push(turn.clone());
diff --git a/crates/shell/src/app_chat/tests.rs b/crates/shell/src/app_chat/tests.rs
index 26a240f6..c9ec586b 100644
--- a/crates/shell/src/app_chat/tests.rs
+++ b/crates/shell/src/app_chat/tests.rs
@@ -149,12 +149,73 @@ fn the_merged_history_names_its_speakers() {
     );
 }
 
+/// The live run's order (#184 follow-up): each lane counts its own
+/// `cursor.seq` (the peer's session is long, the person's context new), and
+/// the kernel sends a turn's user message when the turn ENDS. Replayed as
+/// it arrived: the system agent asks, the person asks while its answer
+/// streams, the person asks again and stops. Each request stands where its
+/// turn started, within a lane in ledger order (an envelope that arrives
+/// after a later one of its lane goes before it), and the stopped turn's
+/// request, which the kernel never records, stays.
+#[test]
+fn two_lanes_interleave_by_arrival_and_a_stopped_request_stays() {
+    let mut c = Conversation::new("News");
+    let sys = LANE_SYSTEM_AGENT;
+    let started = |lane: &str, turn: &str, text: &str, kind: &str| {
+        json!({"method": "turn/started", "lane": lane, "speaker": {"kind": kind},
+            "request": {"text": text, "speaker": {"kind": kind}}, "params": {"turn_id": turn}})
+    };
+    let user = |lane: &str, turn: &str, cursor: u64, text: &str, kind: &str| {
+        json!({"method": "projection/envelope", "lane": lane, "speaker": {"kind": kind}, "display_text": text,
+            "params": {"turn_id": turn, "cursor": {"seq": cursor}, "payload": {"type": "user_message", "data": {"text": text}}}})
+    };
+    // The system agent's digest (the peer's ledger is far along).
+    c.apply(&started(sys, "s1", "Please provide a digest", "system_agent"));
+    c.apply(&env(sys, "s1", 1001, "assistant_delta", json!({"assistant_segment_id": "s1:1", "text": "Gathering"})));
+    c.apply(&env(sys, "s1", 1003, "tool_start", json!({"tool_call_id": "t1", "name": "news_top"})));
+    // Arrives after its lane's later tool_start: goes before it.
+    c.apply(&env(sys, "s1", 1002, "assistant_delta", json!({"assistant_segment_id": "s1:2", "text": "Top stories"})));
+    // The person asks meanwhile (a new context: small seqs).
+    c.apply(&started(LANE_PERSON, "p1", "focus the digest on technology", "person"));
+    c.apply(&env(LANE_PERSON, "p1", 3, "assistant_persisted", json!({"assistant_segment_id": "p1:1", "text": "Tech only."})));
+    c.apply(&env(LANE_PERSON, "p1", 5, "turn_terminal", json!({"outcome": "completed"})));
+    // The kernel records the person's words at the end.
+    c.apply(&user(LANE_PERSON, "p1", 4, "focus the digest on technology", "person"));
+    c.apply(&env(sys, "s1", 1700, "assistant_persisted", json!({"assistant_segment_id": "s1:2", "text": "Top stories: three."})));
+    c.apply(&user(sys, "s1", 1706, "Please provide a digest", "system_agent"));
+    c.apply(&env(sys, "s1", 1707, "turn_terminal", json!({"outcome": "completed"})));
+    // A long request, stopped: no user message ever comes.
+    c.apply(&started(LANE_PERSON, "p2", "a long digest please", "person"));
+    c.apply(&env(LANE_PERSON, "p2", 7, "assistant_delta", json!({"assistant_segment_id": "p2:1", "text": "Working"})));
+    c.apply(&env(LANE_PERSON, "p2", 8, "turn_terminal", json!({"outcome": "interrupted", "error": {"message": "turn interrupted by client"}})));
+    assert!(!c.busy());
+    assert_eq!(
+        labels(&c),
+        [
+            ("System agent".to_string(), "Please provide a digest".to_string()),
+            ("News's agent, to the system agent".to_string(), "Gathering".to_string()),
+            ("News's agent, to the system agent".to_string(), "Top stories: three.".to_string()),
+            ("You".to_string(), "focus the digest on technology".to_string()),
+            ("News's agent".to_string(), "Tech only.".to_string()),
+            ("You".to_string(), "a long digest please".to_string()),
+            ("News's agent".to_string(), "Working".to_string()),
+        ]
+    );
+    let tool = c.chat.items.iter().position(|i| matches!(i, Item::Tool { call_id, .. } if call_id == "t1")).unwrap();
+    let second = c.chat.items.iter().position(|i| matches!(i, Item::Message { segment: Some(s), .. } if s == "s1:2")).unwrap();
+    assert!(second < tool, "ledger order within the lane: {:?}", c.chat.items);
+    assert!(matches!(c.chat.items.last(), Some(Item::Notice(n)) if n == "turn interrupted by client"));
+}
+
 // ---------------------------------------------------------------- the panel
 
 struct FakeContext {
     ops: Mutex<Vec<ContextOp>>,
     open: AtomicBool,
     follower: Mutex<Option<EventSink>>,
+    /// The next turn is stopped: it starts, ends interrupted, and the
+    /// send fails with the same words (as the broker does).
+    stop_next: AtomicBool,
 }
 
 impl OctosContext for FakeContext {
@@ -167,6 +228,22 @@ impl OctosContext for FakeContext {
             ContextOp::History => sink(ContextEvent::Complete(Ok(json!({"messages": [
                 {"role": "user", "content": "[from the system agent] earlier", "lane": "system_agent", "speaker": {"kind": "system_agent"}, "display_text": "earlier"},
             ]})))),
+            ContextOp::TurnFrom { text, .. } if self.stop_next.swap(false, Ordering::SeqCst) => {
+                let follower = self.follower.lock().unwrap().clone();
+                let events = [
+                    json!({"method": "turn/started", "lane": "person", "speaker": {"kind": "person"}, "request": {"text": text, "speaker": {"kind": "person"}},
+                        "params": {"turn_id": "p10"}}),
+                    env("person", "p10", 101, "turn_terminal", json!({"outcome": "interrupted", "error": {"message": "turn interrupted by client"}})),
+                ];
+                for event in events {
+                    // The caller's own turn reaches its sink too.
+                    sink(ContextEvent::Data(event.clone()));
+                    if let Some(follower) = &follower {
+                        follower(ContextEvent::Data(event));
+                    }
+                }
+                sink(ContextEvent::Complete(Err("turn interrupted by client".into())));
+            }
             ContextOp::TurnFrom { text, .. } => {
                 // The kernel's events reach the follower, then the answer.
                 if let Some(follower) = self.follower.lock().unwrap().clone() {
@@ -220,7 +297,7 @@ impl OctosAppService for FakePeer {
         Err("the panel opens the app's conversation, never a plain context".into())
     }
     fn open_conversation(&self, spec: ContextSpec) -> Result<Arc<dyn OctosContext>, String> {
-        let context = Arc::new(FakeContext { ops: Mutex::default(), open: AtomicBool::new(true), follower: Mutex::default() });
+        let context = Arc::new(FakeContext { ops: Mutex::default(), open: AtomicBool::new(true), follower: Mutex::default(), stop_next: AtomicBool::new(false) });
         self.conversations.lock().unwrap().push((spec, context.clone()));
         Ok(context)
     }
@@ -228,6 +305,10 @@ impl OctosAppService for FakePeer {
         *self.prepared.lock().unwrap() += 1;
         Ok(())
     }
+    fn peer_slug(&self) -> Option<String> {
+        // The kernel's slug: the label with an account tag.
+        Some("org-example-asktest-22a12f90".into())
+    }
     fn release(&self) {
         self.released.store(true, Ordering::SeqCst);
         for (_, c) in self.conversations.lock().unwrap().iter() {
@@ -305,10 +386,28 @@ fn the_panel_opens_a_sharing_context_and_sends_person_turns_there() {
     assert!(said.contains(&(Role::User, "You".into(), "focus the digest on technology".into())), "{said:?}");
     assert!(said.contains(&(Role::Assistant, "Ask Test's agent".into(), "Noted.".into())), "{said:?}");
 
+    // A stopped turn: its request line stays, and "interrupted" is said
+    // once (the turn's end), not again for the send's error.
+    context.stop_next.store(true, Ordering::SeqCst);
+    super::send("a long digest please");
+    let model = super::snapshot();
+    let interrupted = model.items.iter().filter(|i| matches!(i, Item::Notice(n) if n == "turn interrupted by client")).count();
+    assert_eq!(interrupted, 1, "{:?}", model.items);
+    assert!(model.items.iter().any(|i| matches!(i, Item::Message { role: Role::User, text, .. } if text == "a long digest please")), "{:?}", model.items);
+
     // The shell prepares an allowed agent's peer: the panel's is the same
     // one (nothing more to do); another allowed app's is bound now.
     crate::agents::prepare(&app);
     assert_eq!(crate::agents::prepared(APP), Some(crate::agents::Prepared::Ready));
+    // The system agent is given the peer's SLUG for peer_send_input, never
+    // just the app id (it tried `os.news` first in the live run).
+    const SLUG: &str = "org-example-asktest-22a12f90";
+    assert_eq!(crate::agents::peer_slug(&app).as_deref(), Some(SLUG));
+    let listed = crate::agents::line(&app);
+    assert_eq!(listed["peer_slug"], SLUG);
+    assert!(listed["what_to_do"].as_str().unwrap().contains(&format!("peer_send_input and the peer slug \"{SLUG}\"")), "{listed}");
+    let note = crate::agents::note_part(&app);
+    assert!(note.contains(SLUG) && note.contains("peer_send_input") && note.contains("not the app id"), "{note}");
     assert_eq!(peers.0.lock().unwrap().len(), 1, "one peer per app");
     const OTHER: &str = "org.example.asktest2";
     crate::approvals::with(|a| a.consent.set(&crate::approvals::rules::ApprovalGesture::sheet_tap(), OTHER, true, 2));
@@ -339,6 +438,7 @@ fn the_system_agent_is_told_about_agents_it_cannot_list() {
     let note = crate::agents::system_note().expect("Rinx has an agent in every build");
     assert!(note.starts_with("[OctoSense: apps with an agent:"), "{note}");
     assert!(note.contains("Rinx [rinx]"), "{note}");
+    assert!(note.contains("peer_send_input takes a peer slug from peer_list, never an app id"), "{note}");
     let sent = format!("{note}\nask News for a digest");
     assert_eq!(crate::agents::strip_note(&sent), "ask News for a digest");
     assert_eq!(crate::agents::strip_note("ask News"), "ask News");