Fix cloud mode for 3rd party harnesses (warpdotdev#10422)

## Description

Fixes the third-party Cloud Mode harness transition so the live harness
block is shown and scoped to the active agent-view conversation when the
harness command starts.

Previously, third-party harness startup teardown reused the generic
startup-command flag flip, which unhid/unmarked the active block. In
runs with earlier setup blocks, the active block may not be the harness
block by the time the event is handled, leaving the actual
Claude/Gemini/OpenCode/Codex block classified as setup output and hidden
from the agent view.

This PR:

- Carries the started harness `BlockId` on
`AmbientAgentViewModelEvent::HarnessCommandStarted`.
- Clears startup-command state on that specific block and attaches it to
the active conversation.
- Keeps earlier setup blocks hidden/collapsible instead of exposing them
as normal terminal blocks.
- Updates event matches for the new event payload.
- Adds a block-list regression test covering the target-block
unhide/attach behavior.

## Linked Issue

N/A

- [ ] The linked issue is labeled `ready-to-spec` or
`ready-to-implement`.
- [ ] Where appropriate, screenshots or a short video of the
implementation are included below (especially for user-visible or UI
changes).

## Testing

- Added
`test_finish_startup_commands_at_block_attaches_and_unhides_only_target_block`
in `app/src/terminal/model/blocks_tests.rs`.
- Not run locally yet.
- [ ] I have manually tested my changes locally with `./script/run`

### Screenshots / Videos

Not included yet; this is a user-visible Cloud Mode behavior change and
should be manually validated with a third-party harness run before
review/merge.

## Agent Mode

- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mod

Co-Authored-By: Oz [oz-agent@warp.dev](mailto:oz-agent@warp.dev)

Author: zachbai

app/src/ai/blocklist/block.rs

@@ -1224,7 +1224,7 @@ impl AIBlock {
                 | AmbientAgentViewModelEvent::Failed { .. }
                 | AmbientAgentViewModelEvent::NeedsGithubAuth
                 | AmbientAgentViewModelEvent::Cancelled
-                | AmbientAgentViewModelEvent::HarnessCommandStarted => ctx.notify(),
+                | AmbientAgentViewModelEvent::HarnessCommandStarted { .. } => ctx.notify(),
                 _ => {}
             });
         }

app/src/terminal/model/blocks.rs

@@ -1342,6 +1342,27 @@ impl BlockList {
         }
     }
 
+    pub fn finish_oz_environment_startup_commands_at_block(
+        &mut self,
+        block_id: &BlockId,
+        conversation_id: Option<AIConversationId>,
+    ) {
+        self.is_executing_oz_environment_startup_commands = false;
+        if let Some(block_index) = self.block_index_for_id(block_id) {
+            for block in self.blocks.iter_mut().skip(block_index.0) {
+                if block.is_background() || block.is_static() {
+                    continue;
+                }
+                block.unhide();
+                block.set_is_oz_environment_startup_command(false);
+                if let Some(conversation_id) = conversation_id {
+                    block.add_attached_conversation_id(conversation_id);
+                }
+            }
+        }
+        self.update_blocks_and_sumtree(None, None, |_| {}, |_| {});
+    }
+
     /// Resets the internal block object's index to its actual index in the block list.
     /// This does not move the block, but is necessary to be called after a move (inserting or removing blocks).
     /// Also updates the block ID to block index mapping.

app/src/terminal/model/blocks_tests.rs

@@ -1565,6 +1565,74 @@ fn test_agent_origin_block_can_be_attached_to_other_conversation() {
     assert!(user_block.is_empty(block_list.agent_view_state()));
 }
 
+#[test]
+fn test_finish_startup_commands_at_block_attaches_and_unhides_command_blocks_since_target_block() {
+    let _agent_view_flag = FeatureFlag::AgentView.override_enabled(true);
+    let mut block_list =
+        new_bootstrapped_block_list(None, None, ChannelEventListener::new_for_test());
+    block_list.set_is_executing_oz_environment_startup_commands(true);
+
+    let setup_block_index = insert_block(&mut block_list, "setup", "output");
+    let harness_block_index = insert_block(&mut block_list, "claude", "output");
+    let followup_block_index = insert_block(&mut block_list, "pwd", "output");
+    let setup_block_id = block_list.block_at(setup_block_index).unwrap().id().clone();
+    let harness_block_id = block_list
+        .block_at(harness_block_index)
+        .unwrap()
+        .id()
+        .clone();
+    let followup_block_id = block_list
+        .block_at(followup_block_index)
+        .unwrap()
+        .id()
+        .clone();
+    let conversation_id = AIConversationId::new();
+
+    block_list.set_agent_view_state(AgentViewState::Active {
+        conversation_id,
+        origin: AgentViewEntryOrigin::ThirdPartyCloudAgent,
+        display_mode: AgentViewDisplayMode::FullScreen,
+        original_conversation_length: 0,
+    });
+
+    block_list
+        .finish_oz_environment_startup_commands_at_block(&harness_block_id, Some(conversation_id));
+
+    assert!(!block_list.is_executing_oz_environment_startup_commands());
+
+    for block_id in [&harness_block_id, &followup_block_id] {
+        let block = block_list
+            .block_with_id(block_id)
+            .expect("block should still exist");
+        assert!(!block.is_hidden());
+        assert!(!block.is_oz_environment_startup_command());
+        assert!(!block.should_hide_block(block_list.agent_view_state()));
+        match block.agent_view_visibility() {
+            AgentViewVisibility::Terminal {
+                pending_conversation_ids,
+                conversation_ids,
+            } => {
+                assert!(pending_conversation_ids.is_empty());
+                assert!(conversation_ids.contains(&conversation_id));
+            }
+            AgentViewVisibility::Agent {
+                origin_conversation_id,
+                pending_other_conversation_ids,
+                other_conversation_ids,
+            } => panic!(
+                "expected terminal visibility, got agent visibility: {origin_conversation_id:?}, {pending_other_conversation_ids:?}, {other_conversation_ids:?}"
+            ),
+        }
+    }
+
+    let setup_block = block_list
+        .block_with_id(&setup_block_id)
+        .expect("setup block should still exist");
+    assert!(setup_block.is_hidden());
+    assert!(setup_block.is_oz_environment_startup_command());
+    assert!(setup_block.should_hide_block(block_list.agent_view_state()));
+}
+
 #[test]
 pub fn test_seek_up_to_next_grid() {
     let mut block_list =

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

@@ -116,7 +116,7 @@ pub fn create_cloud_mode_view(
                 | AmbientAgentViewModelEvent::HarnessSelected
                 | AmbientAgentViewModelEvent::HostSelected
                 | AmbientAgentViewModelEvent::HarnessModelSelected
-                | AmbientAgentViewModelEvent::HarnessCommandStarted
+                | AmbientAgentViewModelEvent::HarnessCommandStarted { .. }
                 | AmbientAgentViewModelEvent::PendingHandoffChanged
                 | AmbientAgentViewModelEvent::HandoffSnapshotUploadFailed { .. }
                 | AmbientAgentViewModelEvent::UpdatedSetupCommandVisibility => {}

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

@@ -5,6 +5,7 @@ use session_sharing_protocol::common::SessionId;
 use warp_cli::agent::Harness;
 use warp_core::features::FeatureFlag;
 use warp_core::send_telemetry_from_ctx;
+use warp_terminal::model::BlockId;
 use warpui::r#async::{SpawnedFutureHandle, Timer};
 use warpui::{AppContext, Entity, EntityId, ModelContext, SingletonEntity};
 
@@ -550,7 +551,11 @@ impl AmbientAgentViewModel {
 
     /// Marks the harness CLI as started and emits `HarnessCommandStarted`.
     /// Idempotent: subsequent calls after the first are no-ops and do not re-emit.
-    pub(super) fn mark_harness_command_started(&mut self, ctx: &mut ModelContext<Self>) {
+    pub(super) fn mark_harness_command_started(
+        &mut self,
+        block_id: BlockId,
+        ctx: &mut ModelContext<Self>,
+    ) {
         debug_assert!(
             self.harness != Harness::Oz,
             "harness_command_started is only meaningful for non-oz runs"
@@ -559,7 +564,7 @@ impl AmbientAgentViewModel {
             return;
         }
         self.harness_command_started = true;
-        ctx.emit(AmbientAgentViewModelEvent::HarnessCommandStarted);
+        ctx.emit(AmbientAgentViewModelEvent::HarnessCommandStarted { block_id });
     }
 
     /// Sets the selected environment ID.
@@ -1413,7 +1418,9 @@ pub enum AmbientAgentViewModelEvent {
     /// The harness CLI (for non-oz runs) has started executing in the shared session.
     /// Fires once per run and signals the transition out of the pre-first-exchange phase
     /// for claude / gemini / other third-party harnesses.
-    HarnessCommandStarted,
+    HarnessCommandStarted {
+        block_id: BlockId,
+    },
     /// The pane's `pending_handoff` was updated.
     PendingHandoffChanged,
     /// The async handoff snapshot upload failed. The input layer subscribes to

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

@@ -111,7 +111,7 @@ impl TerminalView {
             AmbientAgentViewModelEvent::Failed { .. }
                 | AmbientAgentViewModelEvent::NeedsGithubAuth
                 | AmbientAgentViewModelEvent::Cancelled
-                | AmbientAgentViewModelEvent::HarnessCommandStarted
+                | AmbientAgentViewModelEvent::HarnessCommandStarted { .. }
         ) {
             self.remove_pending_user_query_block(ctx);
         }
@@ -297,11 +297,14 @@ impl TerminalView {
             }
             AmbientAgentViewModelEvent::HostSelected => {}
             AmbientAgentViewModelEvent::HarnessModelSelected => {}
-            AmbientAgentViewModelEvent::HarnessCommandStarted => {
-                // Stop classifying new blocks as environment setup commands, mirroring the
-                // Oz path in the `AppendedExchange` handler. Flipping this flag to `false`
-                // also un-hides and un-marks the active block so it renders like a normal
-                // CLI-agent session.
+            AmbientAgentViewModelEvent::HarnessCommandStarted { block_id } => {
+                // Stop classifying the harness block as an environment setup command, mirroring
+                // the Oz path in the `AppendedExchange` handler.
+                let conversation_id = self
+                    .agent_view_controller
+                    .as_ref(ctx)
+                    .agent_view_state()
+                    .active_conversation_id();
                 {
                     let mut model = self.model.lock();
                     if model
@@ -310,7 +313,10 @@ impl TerminalView {
                     {
                         model
                             .block_list_mut()
-                            .set_is_executing_oz_environment_startup_commands(false);
+                            .finish_oz_environment_startup_commands_at_block(
+                                block_id,
+                                conversation_id,
+                            );
                     }
                 }
                 // Collapse the setup-commands summary, matching the oz first-exchange behavior.
@@ -368,10 +374,10 @@ impl TerminalView {
         if ambient_agent_view_model
             .as_ref(ctx)
             .is_third_party_harness()
-            && self.active_block_matches_run_harness(ctx)
+            && self.block_matches_run_harness(block_id, ctx)
         {
             ambient_agent_view_model.update(ctx, |model, ctx| {
-                model.mark_harness_command_started(ctx);
+                model.mark_harness_command_started(block_id.clone(), ctx);
             });
             return;
         }
@@ -511,19 +517,20 @@ impl TerminalView {
         }
     }
 
-    /// Returns `true` when the active block's command is the CLI for the run's configured
+    /// Returns `true` when the block's command is the CLI for the run's configured
     /// non-oz harness (e.g. `claude …` for [`Harness::Claude`]).
     /// Used to detect the harness-start transition at `AfterBlockStarted` time. Unlike
     /// `detect_cli_agent_from_model`, this does NOT gate on `is_active_and_long_running` —
     /// we want to classify the block as the harness session as soon as it starts, before the
     /// long-running timer would otherwise elapse.
-    fn active_block_matches_run_harness(&self, ctx: &AppContext) -> bool {
-        let command = self
-            .model
-            .lock()
-            .block_list()
-            .active_block()
-            .command_with_secrets_obfuscated(false);
+    fn block_matches_run_harness(&self, block_id: &BlockId, ctx: &AppContext) -> bool {
+        let command = {
+            let model = self.model.lock();
+            let Some(block) = model.block_list().block_with_id(block_id) else {
+                return false;
+            };
+            block.command_with_secrets_obfuscated(false)
+        };
         let Some(cli_agent) = CLIAgent::detect(&command, None, None, ctx) else {
             return false;
         };