Join the live session when hydrating remote-child panes

Revealing a subtree-discovered descendant of a running orchestration
rendered the empty cloud zero-state instead of the run's transcript. The
task-backed hydration path's LiveAttach arm only called
enter_viewing_existing_session, which binds the task to the ambient view
model but never connects the pane's deferred shared-session viewer
TerminalManager to the run's execution session — the join drivers
(SessionReady / ExecutionSessionReady) only fire from the dispatch-time
spawn stream or an explicit attach_execution_session, neither of which
runs on the restore/discovery path. Direct children masked the gap
because their panes join via the spawn stream at dispatch; discovered
descendants always hydrate through this path.

LiveAttach now carries the parsed session id and the dispatch arm
records it on the ambient view model and connects the deferred viewer
with full scrollback replay (not the follow-up append mode, which
suppresses the agent-conversation replay), so a mid-run join backfills
the transcript so far. Restored direct children of a still-running
orchestration get the same fix on reveal after a restart.

Co-Authored-By: Warp Agent <agent@warp.dev>

Author: danielpeng2

app/src/pane_group/child_agent/hydration.rs

@@ -1,3 +1,4 @@
+use session_sharing_protocol::common::SessionId;
 use warp_errors::report_error;
 use warpui::{SingletonEntity, ViewContext};
 
@@ -11,6 +12,7 @@ use crate::ai::blocklist::BlocklistAIHistoryModel;
 use crate::ai::blocklist::agent_view::AgentViewEntryOrigin;
 use crate::ai::blocklist::history_model::CloudConversationData;
 use crate::pane_group::{AmbientAgentViewModelHandleExt, PaneGroup, PaneId};
+use crate::terminal::shared_session;
 use crate::terminal::view::load_ai_conversation::{
     RestoreConversationEntryBehavior, RestoredAIConversation,
 };
@@ -20,7 +22,7 @@ use crate::terminal::view::load_ai_conversation::{
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(in crate::pane_group) enum RemoteChildHydrationAction {
     /// Attachable live session — join it in place.
-    LiveAttach,
+    LiveAttach { session_id: SessionId },
     /// No live session but a server conversation token is available;
     /// `task_is_terminal` controls whether the post-merge step inserts a
     /// conversation-ended tombstone (only terminal runs do).
@@ -41,11 +43,8 @@ pub(in crate::pane_group) fn decide_remote_child_hydration_action(
     task: &AmbientAgentTask,
 ) -> RemoteChildHydrationAction {
     let live_session_state = task.active_live_session_state();
-    if matches!(
-        live_session_state,
-        AmbientAgentLiveSessionState::Attachable { .. }
-    ) {
-        return RemoteChildHydrationAction::LiveAttach;
+    if let AmbientAgentLiveSessionState::Attachable { session_id } = live_session_state {
+        return RemoteChildHydrationAction::LiveAttach { session_id };
     }
 
     let task_is_terminal = matches!(live_session_state, AmbientAgentLiveSessionState::Inactive);
@@ -188,8 +187,9 @@ impl PaneGroup {
         };
 
         match decide_remote_child_hydration_action(&task) {
-            RemoteChildHydrationAction::LiveAttach => {
+            RemoteChildHydrationAction::LiveAttach { session_id } => {
                 self.apply_existing_ambient_task_to_pane(pane_id, child_id, task_id, ctx);
+                self.connect_hidden_child_pane_to_live_session(pane_id, session_id, ctx);
             }
             RemoteChildHydrationAction::LoadTranscript {
                 server_token,
@@ -220,6 +220,65 @@ impl PaneGroup {
         }
     }
 
+    /// Connects a hydrated hidden child pane's deferred shared-session
+    /// viewer to the run's live execution session.
+    ///
+    /// `enter_viewing_existing_session` only binds the task to the ambient
+    /// view model; the deferred viewer `TerminalManager` still needs an
+    /// explicit join, otherwise the pane renders the empty cloud zero-state
+    /// while the run streams. The join drivers used by dispatch-time panes
+    /// (`SessionReady` / `ExecutionSessionReady`) only fire from the spawn
+    /// stream or an explicit `attach_execution_session`, neither of which
+    /// runs on this restore/discovery path. Connects with full scrollback
+    /// replay (not the follow-up append mode, which suppresses the agent
+    /// conversation replay) so a mid-run join backfills the transcript.
+    fn connect_hidden_child_pane_to_live_session(
+        &mut self,
+        pane_id: PaneId,
+        session_id: SessionId,
+        ctx: &mut ViewContext<Self>,
+    ) {
+        if let Some(terminal_view) = self.terminal_view_from_pane_id(pane_id, ctx) {
+            terminal_view.update(ctx, |terminal_view, ctx| {
+                if let Some(ambient_agent_view_model) = terminal_view
+                    .ambient_agent_view_model()
+                    .into_optional_handle()
+                    .cloned()
+                {
+                    // Record the live session without emitting
+                    // `ExecutionSessionReady` — the viewer join below is
+                    // driven directly, and the recorded id keeps
+                    // `is_ready_for_cloud_followup_prompt` false while the
+                    // session is live.
+                    ambient_agent_view_model.update(ctx, |model, _| {
+                        model.set_live_execution_session(session_id);
+                    });
+                }
+                terminal_view.prepare_for_live_session_reattach(ctx);
+            });
+        }
+
+        let Some(terminal_manager) = self
+            .terminal_session_by_id(pane_id)
+            .map(|session| session.terminal_manager(ctx))
+        else {
+            return;
+        };
+        terminal_manager.update(ctx, |terminal_manager, ctx| {
+            let Some(viewer_manager) = terminal_manager
+                .as_any_mut()
+                .downcast_mut::<shared_session::viewer::TerminalManager>()
+            else {
+                log::warn!(
+                    "connect_hidden_child_pane_to_live_session: pane manager is not a \
+                     shared-session viewer"
+                );
+                return;
+            };
+            viewer_manager.connect_to_session(session_id, false, ctx);
+        });
+    }
+
     /// Attaches the hidden child pane's ambient agent view model to the
     /// live ambient session for `task_id`. Wrapper around
     /// `AmbientAgentViewModel::enter_viewing_existing_session` that also

app/src/pane_group/mod_tests.rs

@@ -1008,6 +1008,85 @@ fn test_restored_remote_hidden_child_pane_enters_existing_ambient_session() {
     });
 }
 
+/// A hydrated remote-child placeholder whose task has an attachable live
+/// session must actually join that session — not just bind the task to the
+/// ambient view model. Regression test for revealing a subtree-discovered
+/// descendant of a running orchestration rendering the empty cloud
+/// zero-state: `enter_viewing_existing_session` moved the pane to
+/// `AgentRunning` but the deferred shared-session viewer was never
+/// connected, so no transcript streamed. Direct children mask this because
+/// their dispatch-time panes join via the spawn stream; this hydration path
+/// is the only join driver for restored/discovered placeholders.
+#[test]
+fn test_hydrated_remote_child_with_attachable_live_session_joins_shared_session() {
+    App::test((), |mut app| async move {
+        initialize_app(&mut app);
+        let pane_group = mock_pane_group(&mut app, Default::default());
+
+        pane_group.update(&mut app, |panes, ctx| {
+            let parent_pane_id = get_newly_created_pane_id(panes, &[]);
+            let parent_conversation_id = start_parent_conversation(panes, parent_pane_id, ctx);
+            let task_id = new_ambient_agent_task_id();
+            let session_id: SessionId = "22222222-2222-2222-2222-222222222222".parse().unwrap();
+
+            let mut task = ambient_agent_task_for_current_user(task_id);
+            task.state = AmbientAgentTaskState::InProgress;
+            task.is_sandbox_running = true;
+            task.session_id = Some(session_id.to_string());
+            AgentConversationsModel::handle(ctx).update(ctx, |model, _| {
+                model.insert_task_for_test(task);
+            });
+
+            let mut child_conversation = AIConversation::new(false, false);
+            child_conversation.set_parent_conversation_id(parent_conversation_id);
+            child_conversation.set_task_id(task_id);
+            child_conversation.mark_as_remote_child();
+            let child_conversation_id = child_conversation.id();
+
+            panes.create_hidden_child_agent_pane(child_conversation, parent_pane_id, ctx);
+
+            let child_pane_id = panes
+                .child_agent_panes
+                .get(&child_conversation_id)
+                .copied()
+                .expect("hydrated remote child pane should be tracked");
+
+            let (ambient_task_id, is_agent_running, active_conversation_id) =
+                ambient_child_session_state(panes, child_pane_id, ctx);
+            assert_eq!(ambient_task_id, Some(task_id));
+            assert!(is_agent_running);
+            assert_eq!(active_conversation_id, Some(child_conversation_id));
+
+            let terminal_view = panes
+                .terminal_view_from_pane_id(child_pane_id, ctx)
+                .expect("remote child pane should have a terminal view");
+            assert_eq!(
+                terminal_view
+                    .as_ref(ctx)
+                    .ambient_agent_view_model()
+                    .expect("child pane should have an ambient agent model")
+                    .as_ref(ctx)
+                    .active_execution_session_id_for_test(),
+                Some(session_id),
+                "live-attach hydration must record the run's live execution session",
+            );
+
+            // The join is initiated synchronously: `connect_session` moves
+            // the deferred viewer to `ViewPending` before the async network
+            // handshake runs.
+            assert!(
+                terminal_view
+                    .as_ref(ctx)
+                    .model
+                    .lock()
+                    .shared_session_status()
+                    .is_view_pending(),
+                "live-attach hydration must connect the deferred shared-session viewer",
+            );
+        });
+    });
+}
+
 /// Fix B: when task data for a restored remote child is NOT yet cached at
 /// `create_hidden_child_agent_pane` time, the placeholder must still be
 /// registered in `child_agent_panes` keyed by its local AIConversationId,
@@ -3301,6 +3380,9 @@ fn hydration_decision_task(
 #[test]
 fn decide_remote_child_hydration_attachable_live_session_chooses_live_attach() {
     // InProgress + sandbox running + parseable session id -> Attachable.
+    // The decision must carry the parsed session id so the dispatch arm can
+    // actually join the live session.
+    let session_id: SessionId = "11111111-1111-1111-1111-111111111111".parse().unwrap();
     let task = hydration_decision_task(
         AmbientAgentTaskState::InProgress,
         true,
@@ -3309,14 +3391,12 @@ fn decide_remote_child_hydration_attachable_live_session_chooses_live_attach() {
     );
     assert_eq!(
         task.active_live_session_state(),
-        AmbientAgentLiveSessionState::Attachable {
-            session_id: "11111111-1111-1111-1111-111111111111".parse().unwrap(),
-        },
+        AmbientAgentLiveSessionState::Attachable { session_id },
     );
 
     assert_eq!(
         decide_remote_child_hydration_action(&task),
-        RemoteChildHydrationAction::LiveAttach,
+        RemoteChildHydrationAction::LiveAttach { session_id },
     );
 }
 

app/src/terminal/view/ambient_agent/model.rs

@@ -882,6 +882,12 @@ impl AmbientAgentViewModel {
         ctx.emit(AmbientAgentViewModelEvent::EnvironmentSelected);
     }
 
+    /// Test-only accessor for the recorded live execution session id.
+    #[cfg(test)]
+    pub fn active_execution_session_id_for_test(&self) -> Option<SessionId> {
+        self.active_execution_session_id
+    }
+
     pub fn record_ambient_execution_ended(
         &mut self,
         session_id: SessionId,