fix(agent): propagate delegated confirmations

Author: ZhiXiao-Lin

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Forwarded delegated child confirmation-required, confirmation-received, and
+  confirmation-timeout events through the parent runtime stream so shared HITL
+  providers cannot deadlock while the host UI waits for an event it never saw.
+- Built MCP tool-selection context from the last six text-bearing messages
+  instead of counting tool-use and tool-result messages that are discarded,
+  preserving the original request across long delegated tool sequences.
+
 ## [6.1.0] - 2026-07-20
 
 ### Added

core/src/agent_api/runtime_events.rs

@@ -487,6 +487,13 @@ fn should_bridge_agent_event(event: &AgentEvent) -> bool {
         AgentEvent::SubagentStart { .. }
             | AgentEvent::SubagentProgress { .. }
             | AgentEvent::SubagentEnd { .. }
+            // A delegated child that inherits the parent confirmation provider
+            // waits for the parent UI to answer these events. Filtering them
+            // here leaves the child blocked even though its confirmation is
+            // registered on the shared provider.
+            | AgentEvent::ConfirmationRequired { .. }
+            | AgentEvent::ConfirmationReceived { .. }
+            | AgentEvent::ConfirmationTimeout { .. }
     )
 }
 
@@ -761,6 +768,72 @@ mod tests {
         )));
     }
 
+    #[tokio::test]
+    async fn forwarder_exposes_delegated_confirmation_lifecycle() {
+        let run_store = Arc::new(crate::run::InMemoryRunStore::new());
+        let run = run_store.create_run("session-1", "prompt").await;
+        let sink = RuntimeEventSink::new(RuntimeEventSinkConfig {
+            run_store: Arc::clone(&run_store),
+            run_id: run.id.clone(),
+            session_id: "session-1".to_string(),
+            hook_executor: None,
+            security_provider: None,
+            persistence_state: persistence_state(),
+            active_tools: active_tools(),
+            subagent_tasks: Arc::new(
+                crate::subagent_task_tracker::InMemorySubagentTaskTracker::new(),
+            ),
+        });
+        let (runtime_tx, runtime_rx) = mpsc::channel(4);
+        let (stream_tx, mut stream_rx) = mpsc::channel(4);
+        let (agent_tx, barrier, agent_rx) = run_agent_event_channel(8);
+        let forwarder = sink.spawn_forwarder(runtime_rx, stream_tx, Some(agent_rx));
+
+        let expected = vec![
+            AgentEvent::ConfirmationRequired {
+                tool_id: "child-tool-1".to_string(),
+                tool_name: "install".to_string(),
+                args: serde_json::json!({"component": "browser"}),
+                timeout_ms: 30_000,
+            },
+            AgentEvent::ConfirmationReceived {
+                tool_id: "child-tool-1".to_string(),
+                approved: true,
+                reason: Some("approved by parent".to_string()),
+            },
+            AgentEvent::ConfirmationTimeout {
+                tool_id: "child-tool-2".to_string(),
+                action_taken: "rejected".to_string(),
+            },
+        ];
+        for event in &expected {
+            agent_tx.send(event.clone()).unwrap();
+        }
+        barrier.flush().await;
+        drop(agent_tx);
+        drop(runtime_tx);
+        forwarder.await.unwrap();
+
+        let mut streamed = Vec::new();
+        while let Some(event) = stream_rx.recv().await {
+            streamed.push(event);
+        }
+        assert_eq!(
+            serde_json::to_value(&streamed).unwrap(),
+            serde_json::to_value(&expected).unwrap()
+        );
+        let persisted = run_store
+            .events(&run.id)
+            .await
+            .into_iter()
+            .map(|record| record.event)
+            .collect::<Vec<_>>();
+        assert_eq!(
+            serde_json::to_value(&persisted).unwrap(),
+            serde_json::to_value(&expected).unwrap()
+        );
+    }
+
     #[tokio::test]
     async fn forwarder_exposes_and_persists_only_sanitized_events() {
         let run_store = Arc::new(crate::run::InMemoryRunStore::new());

core/src/tools/selector.rs

@@ -191,17 +191,27 @@ fn should_include_mcp_tool(
 }
 
 fn selection_context(messages: &[Message]) -> String {
-    let mut parts = Vec::new();
-    for message in messages.iter().rev().take(6).rev() {
-        if message.role == "tool" {
-            continue;
-        }
-        for block in &message.content {
-            if let ContentBlock::Text { text } = block {
-                parts.push(text.as_str());
+    let mut parts = messages
+        .iter()
+        .rev()
+        .filter_map(|message| {
+            if message.role == "tool" {
+                return None;
             }
-        }
-    }
+            let text = message
+                .content
+                .iter()
+                .filter_map(|block| match block {
+                    ContentBlock::Text { text } => Some(text.as_str()),
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+                .join("\n");
+            (!text.is_empty()).then_some(text)
+        })
+        .take(6)
+        .collect::<Vec<_>>();
+    parts.reverse();
     parts.join("\n")
 }
 
@@ -411,4 +421,32 @@ mod tests {
 
         assert_eq!(names, vec!["mcp__use_report__fixture_tool"]);
     }
+
+    #[test]
+    fn tool_heavy_history_keeps_the_original_textual_intent() {
+        let tool = "mcp__use_browser__agent_browser_open";
+        let mut messages = vec![Message::user(&format!("Call {tool} after diagnostics"))];
+        for index in 0..3 {
+            let id = format!("call-{index}");
+            messages.push(Message {
+                role: "assistant".to_string(),
+                content: vec![ContentBlock::ToolUse {
+                    id: id.clone(),
+                    name: format!("diagnostic-{index}"),
+                    input: json!({}),
+                }],
+                reasoning_content: None,
+            });
+            messages.push(Message::tool_result(&id, "ok", false));
+        }
+
+        let selected = select_tools_for_messages(&defs(&[tool]), &messages);
+        assert_eq!(
+            selected
+                .iter()
+                .map(|definition| definition.name.as_str())
+                .collect::<Vec<_>>(),
+            vec![tool]
+        );
+    }
 }