Harness API messages are accepted but invisible in an already attached TUI

diff --git a/crates/jcode-app-core/src/server/client_lifecycle.rs b/crates/jcode-app-core/src/server/client_lifecycle.rs
index 639a820..5bd12f3 100644
--- a/crates/jcode-app-core/src/server/client_lifecycle.rs
+++ b/crates/jcode-app-core/src/server/client_lifecycle.rs
@@ -1188,6 +1188,7 @@ pub(super) async fn handle_client(
                         client_is_processing,
                         &agent,
                         &client_event_tx,
+                        &swarm_members,
                     )
                     .await;
                     continue;
@@ -3115,6 +3116,7 @@ async fn append_context_message(
     client_is_processing: bool,
     agent: &Arc<Mutex<Agent>>,
     client_event_tx: &mpsc::UnboundedSender<ServerEvent>,
+    swarm_members: &Arc<RwLock<HashMap<String, SwarmMember>>>,
 ) {
     let Ok(mut agent) = agent.try_lock() else {
         send_agent_busy_error(
@@ -3135,7 +3137,38 @@ async fn append_context_message(
             retry_after_secs: None,
         },
     };
+    let accepted = matches!(event, ServerEvent::ContextMessageAdded { .. });
     let _ = client_event_tx.send(event);
+    drop(agent);
+    if accepted {
+        echo_remote_user_message(swarm_members, client_session_id, client_event_tx, content).await;
+    }
+}
+
+async fn echo_remote_user_message(
+    members: &Arc<RwLock<HashMap<String, SwarmMember>>>,
+    session_id: &str,
+    sender: &mpsc::UnboundedSender<ServerEvent>,
+    content: &str,
+) {
+    let targets = {
+        let members = members.read().await;
+        let Some(member) = members.get(session_id) else {
+            return;
+        };
+        member
+            .event_txs
+            .values()
+            .filter(|tx| !tx.same_channel(sender))
+            .cloned()
+            .collect::<Vec<_>>()
+    };
+    for tx in targets {
+        let _ = tx.send(ServerEvent::RemoteUserMessage {
+            session_id: session_id.to_string(),
+            content: content.to_string(),
+        });
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -3188,6 +3221,8 @@ async fn start_processing_message(
         return;
     }
 
+    echo_remote_user_message(swarm.members, client_session_id, client_event_tx, &content).await;
+
     *state.client_is_processing = true;
     *state.message_id = Some(id);
     *state.session_id = Some(client_session_id.to_string());
diff --git a/crates/jcode-protocol/src/wire.rs b/crates/jcode-protocol/src/wire.rs
index d300ced..3943cf1 100644
--- a/crates/jcode-protocol/src/wire.rs
+++ b/crates/jcode-protocol/src/wire.rs
@@ -1045,6 +1045,11 @@ pub enum ServerEvent {
     #[serde(rename = "context_message_added")]
     ContextMessageAdded { id: u64 },
 
+    /// Echo an accepted user message to other clients attached to this session.
+    /// The submitting client already displays its own input locally.
+    #[serde(rename = "remote_user_message")]
+    RemoteUserMessage { session_id: String, content: String },
+
     /// Error occurred
     #[serde(rename = "error")]
     Error {
diff --git a/crates/jcode-tui/src/tui/app/remote/server_events.rs b/crates/jcode-tui/src/tui/app/remote/server_events.rs
index 1a2f2be..8e2a3bb 100644
--- a/crates/jcode-tui/src/tui/app/remote/server_events.rs
+++ b/crates/jcode-tui/src/tui/app/remote/server_events.rs
@@ -1499,6 +1499,17 @@ pub(in crate::tui::app) fn handle_server_event(
             app.status_notice = Some((format!("Reload: {}", message), std::time::Instant::now()));
             false
         }
+        ServerEvent::RemoteUserMessage {
+            session_id,
+            content,
+        } => {
+            if app.remote_session_id.as_deref().unwrap_or(&app.session.id) == session_id {
+                app.commit_pending_streaming_assistant_message();
+                app.push_display_message(DisplayMessage::user(content));
+                return true;
+            }
+            false
+        }
         ServerEvent::History {
             messages,
             images,

diff --git a/crates/jcode-app-core/src/server/client_lifecycle_tests.rs b/crates/jcode-app-core/src/server/client_lifecycle_tests.rs
index 59e6273..31406e7 100644
--- a/crates/jcode-app-core/src/server/client_lifecycle_tests.rs
+++ b/crates/jcode-app-core/src/server/client_lifecycle_tests.rs
@@ -210,6 +210,35 @@ async fn context_message_persists_without_starting_turn() {
     )));
     let (client_event_tx, mut client_event_rx) = mpsc::unbounded_channel::<ServerEvent>();
     let before = agent.lock().await.message_count();
+    let (observer_tx, mut observer_rx) = mpsc::unbounded_channel();
+    let members = Arc::new(RwLock::new(HashMap::from([(
+        session_id.to_string(),
+        SwarmMember {
+            session_id: session_id.to_string(),
+            event_tx: client_event_tx.clone(),
+            event_txs: HashMap::from([
+                ("origin".to_string(), client_event_tx.clone()),
+                ("observer".to_string(), observer_tx),
+            ]),
+            working_dir: None,
+            swarm_id: None,
+            swarm_enabled: false,
+            status: "ready".to_string(),
+            detail: None,
+            task_label: None,
+            friendly_name: None,
+            report_back_to_session_id: None,
+            latest_completion_report: None,
+            role: "agent".to_string(),
+            joined_at: Instant::now(),
+            last_status_change: Instant::now(),
+            is_headless: false,
+            output_tail: None,
+            todo_progress: None,
+            todo_items: Vec::new(),
+            runtime: crate::protocol::SwarmMemberRuntime::default(),
+        },
+    )])));
 
     append_context_message(
         77,
@@ -219,6 +248,7 @@ async fn context_message_persists_without_starting_turn() {
         false,
         &agent,
         &client_event_tx,
+        &members,
     )
     .await;
 
@@ -228,6 +258,31 @@ async fn context_message_persists_without_starting_turn() {
     ));
     assert!(client_event_rx.try_recv().is_err());
     assert!(!forked.load(Ordering::SeqCst));
+    assert!(matches!(observer_rx.try_recv().unwrap(),
+        ServerEvent::RemoteUserMessage { session_id: target, content }
+        if target == session_id && content == "remember this context"));
+    assert!(observer_rx.try_recv().is_err());
+    let guard = agent.lock().await;
+    append_context_message(
+        78,
+        "rejected",
+        vec![],
+        session_id,
+        true,
+        &agent,
+        &client_event_tx,
+        &members,
+    )
+    .await;
+    assert!(matches!(
+        client_event_rx.try_recv().unwrap(),
+        ServerEvent::Error { .. }
+    ));
+    assert!(
+        observer_rx.try_recv().is_err(),
+        "rejected input must not be echoed"
+    );
+    drop(guard);
 
     let persisted = crate::session::Session::load(session_id).expect("persisted session");
     assert_eq!(persisted.messages.len(), before + 1);
@@ -263,6 +318,7 @@ async fn context_message_rejects_while_busy_without_waiting_for_agent_lock() {
             true,
             &agent,
             &client_event_tx,
+            &Arc::new(RwLock::new(HashMap::new())),
         )
         .await;
     })
@@ -991,7 +1047,7 @@ fn reload_starting_rejects_new_turn_without_spawning_processing_task() {
 #[tokio::test]
 async fn client_initiated_turn_fans_out_stream_and_terminal_events_to_live_attachments() {
     let _guard = crate::storage::lock_test_env();
-    let _runtime = IsolatedRuntimeDir::new();
+    let _runtime = IsolatedReloadRecoveryEnv::new();
     let session_id = "session_live_attachment_fanout";
 
     let provider: Arc<dyn Provider> = Arc::new(FanoutStreamProvider);
@@ -1004,12 +1060,16 @@ async fn client_initiated_turn_fans_out_stream_and_terminal_events_to_live_attac
 
     let (origin_tx, mut origin_rx) = mpsc::unbounded_channel::<ServerEvent>();
     let (attached_tx, mut attached_rx) = mpsc::unbounded_channel::<ServerEvent>();
+    let (echo_tx, mut echo_rx) = mpsc::unbounded_channel();
     let swarm_members = Arc::new(RwLock::new(HashMap::from([(
         session_id.to_string(),
         SwarmMember {
             session_id: session_id.to_string(),
             event_tx: origin_tx.clone(),
-            event_txs: HashMap::from([("origin".to_string(), origin_tx.clone())]),
+            event_txs: HashMap::from([
+                ("origin".to_string(), origin_tx.clone()),
+                ("echo".to_string(), echo_tx),
+            ]),
             working_dir: None,
             swarm_id: None,
             swarm_enabled: false,
@@ -1068,11 +1128,18 @@ async fn client_initiated_turn_fans_out_stream_and_terminal_events_to_live_attac
     )
     .await;
 
+    assert!(matches!(echo_rx.try_recv().unwrap(),
+        ServerEvent::RemoteUserMessage { session_id: target, content }
+        if target == session_id && content == "stream to every attachment"));
     loop {
         let event = tokio::time::timeout(Duration::from_secs(2), origin_rx.recv())
             .await
             .expect("origin should receive the initial stream event promptly")
             .expect("origin event channel should remain open");
+        assert!(
+            !matches!(event, ServerEvent::RemoteUserMessage { .. }),
+            "no duplicate sender echo"
+        );
         if matches!(event, ServerEvent::TextDelta { ref text } if text == "before attach") {
             break;
         }
diff --git a/crates/jcode-protocol/src/protocol_tests/core_events.rs b/crates/jcode-protocol/src/protocol_tests/core_events.rs
index 12ab75b..ca6547d 100644
--- a/crates/jcode-protocol/src/protocol_tests/core_events.rs
+++ b/crates/jcode-protocol/src/protocol_tests/core_events.rs
@@ -637,3 +637,17 @@ fn test_error_event_retry_after_back_compat_default() -> Result<()> {
     assert_eq!(retry_after_secs, None);
     Ok(())
 }
+
+#[test]
+fn remote_user_message_roundtrip() {
+    let event = ServerEvent::RemoteUserMessage {
+        session_id: "review-target".to_string(),
+        content: "[Codex reviewer] 지시\nsecond line".to_string(),
+    };
+    let encoded = serde_json::to_string(&event).unwrap();
+    let decoded: ServerEvent = serde_json::from_str(&encoded).unwrap();
+    assert!(
+        matches!(decoded, ServerEvent::RemoteUserMessage { session_id, content }
+        if session_id == "review-target" && content == "[Codex reviewer] 지시\nsecond line")
+    );
+}
diff --git a/crates/jcode-tui/src/tui/app/tests/remote_events_reload_01/part_01.rs b/crates/jcode-tui/src/tui/app/tests/remote_events_reload_01/part_01.rs
index d972f8e..ed5d3a1 100644
--- a/crates/jcode-tui/src/tui/app/tests/remote_events_reload_01/part_01.rs
+++ b/crates/jcode-tui/src/tui/app/tests/remote_events_reload_01/part_01.rs
@@ -2012,3 +2012,52 @@ fn test_pending_startup_notice_survives_history_bootstrap_for_fresh_session() {
         "startup notice should be re-applied exactly once after bootstrap"
     );
 }
+
+#[test]
+fn remote_user_message_preserves_draft_and_turn_state() {
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let _guard = rt.enter();
+    for processing in [false, true] {
+        let mut app = create_test_app();
+        let mut remote = crate::tui::backend::RemoteConnection::dummy();
+        app.remote_session_id = Some("review-target".to_string());
+        app.input = "unfinished user draft".to_string();
+        app.cursor_pos = 4;
+        app.is_processing = processing;
+        app.current_message_id = processing.then_some(7);
+        let before = app.display_messages().len();
+        for target in ["other-session", "review-target"] {
+            let redraw = app.handle_server_event(
+                crate::protocol::ServerEvent::RemoteUserMessage {
+                    session_id: target.to_string(),
+                    content: "[Codex reviewer] preserve this instruction verbatim".to_string(),
+                },
+                &mut remote,
+            );
+            assert_eq!(redraw, target == "review-target");
+        }
+        assert_eq!(app.display_messages().len(), before + 1);
+        assert_eq!(
+            app.display_messages().last().unwrap().content,
+            "[Codex reviewer] preserve this instruction verbatim"
+        );
+        assert_eq!(app.input, "unfinished user draft");
+        assert_eq!(app.cursor_pos, 4);
+        assert_eq!(app.is_processing, processing);
+        assert_eq!(app.current_message_id, processing.then_some(7));
+        let backend = ratatui::backend::TestBackend::new(100, 32);
+        let mut terminal = ratatui::Terminal::new(backend).unwrap();
+        terminal
+            .draw(|frame| crate::tui::ui::draw(frame, &app))
+            .unwrap();
+        let rendered = terminal
+            .backend()
+            .buffer()
+            .content
+            .iter()
+            .map(|cell| cell.symbol())
+            .collect::<String>();
+        assert!(rendered.contains("[Codex reviewer] preserve this instruction verbatim"));
+        assert!(rendered.contains("unfinished user draft"));
+    }
+}