Lightweight coding agent that runs in your terminal
Rust
Reload Multi-Agent V2 children through their parent (#40477)
rhan-oaid21794d6ba79
diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.mdindex 23ef7ed4d0..76dc294f3f 100644--- a/codex-rs/app-server/README.md+++ b/codex-rs/app-server/README.md@@ -363,6 +363,8 @@ Valid `personality` values are `"friendly"`, `"pragmatic"`, and `"none"`. When `To continue a stored session, call `thread/resume` with the `thread.id` you previously recorded. The response shape matches `thread/start`. When the stored session includes persisted token usage, the server emits `thread/tokenUsage/updated` immediately after the response so clients can render restored usage before the next turn starts. You can also pass the same configuration overrides supported by `thread/start`, including `approvalsReviewer`. On cold resume, approval policy and the active permission-profile ID select a source in this order: request override, latest persisted thread setting, current configured default. The persisted profile ID is resolved through the same config and requirements path as a `permissions` override. Threads without an active profile ID use current config instead of restoring their concrete historical permissions.+Parent-owned Multi-Agent V2 children are an exception: `thread/resume` ignores configuration overrides and reattaches to the existing child. An unloaded child is reloaded through its actual, currently loaded parent using parent-derived configuration. If that owner-controlled reload cannot be performed, the request returns JSON-RPC error `-32600`; resume the parent first, or use `thread/read` or `thread/turns/list` to inspect the child's stored history without loading it. This policy follows the child's multi-agent runtime, including leaf workers whose models cannot delegate further.+By default, `thread/resume` includes the reconstructed turn history in `thread.turns`. Experimental clients can pass `excludeTurns: true` to return only thread metadata and live resume state, then call `thread/turns/list` separately if they want to page the turn history over the network. A cold paginated resume can still replay persisted `thread/tokenUsage/updated` when it can identify the corresponding stored turn; resuming an already-loaded thread waits for the next live update.Paginated threads keep the same resume contract as legacy threads. A default resume materializes the full projected history into `thread.turns`; `excludeTurns: true` keeps that array empty and includes `turnsBackwardsCursor` and `itemsBackwardsCursor` for the durable history visible at the resume boundary. Pass each cursor directly to its matching list API with `sortDirection: "desc"`; the first page includes the row identified by the cursor, while newer records arrive through live notifications. Either cursor is `null` when there is no durable row yet.diff --git a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs b/codex-rs/app-server/src/request_processors/thread_lifecycle.rsindex 422adbb578..2cbf81d085 100644--- a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs+++ b/codex-rs/app-server/src/request_processors/thread_lifecycle.rs@@ -661,9 +661,11 @@ pub(super) async fn handle_pending_thread_resume_request(} else {None};- let token_usage_turn_id = pending- .include_turns- .then(|| restored_token_usage_turn_id(&pending.history_items, thread.turns.as_slice()));+ let token_usage_turn_id = pending.cold_resume_token_usage_turn_id.or_else(|| {+ pending+ .include_turns+ .then(|| restored_token_usage_turn_id(&pending.history_items, thread.turns.as_slice()))+ });if pending.initial_turns_page.is_none() {initial_turns_page = None;}@@ -762,8 +764,8 @@ pub(super) async fn handle_pending_thread_resume_request(outgoing.send_response_with_thread_originator(request_id, response, originator).await;- // Match cold resume: metadata-only resume should attach the listener without- // paying the cost of turn reconstruction for historical usage replay.+ // Warm metadata-only resumes skip history reconstruction. Cold paginated children can+ // replay usage using attribution captured before the listener was attached.if let Some(token_usage_turn_id) = token_usage_turn_id {// Rejoining a loaded thread has the same UI contract as a cold resume, but// uses the live conversation state instead of reconstructing a new session.diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex 079c15e33d..be6c016a11 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -3538,6 +3538,7 @@ impl ThreadRequestProcessor {¶ms,app_server_client_name.clone(),app_server_client_version.clone(),+ /*cold_resume_history*/ None,).await{@@ -3607,6 +3608,51 @@ impl ThreadRequestProcessor {});let paginated_resume = paginated_thread_id.is_some();+ // Parent-owned V2 children must resume through their owner, not caller configuration.+ if let InitialHistory::Resumed(resumed_history) = &thread_history+ && let Some((source, _)) = thread_history.get_resumed_session_sources()+ && !can_accept_direct_input(thread_history.get_multi_agent_version(), &source)+ {+ let child_thread_id = resumed_history.conversation_id;+ self.thread_manager+ .ensure_multi_agent_v2_child_loaded(child_thread_id)+ .await+ .map_err(|err| {+ tracing::warn!(+ thread_id = %child_thread_id,+ error = %err,+ "failed to resume a multi-agent v2 child through its parent"+ );+ invalid_request(+ "cannot resume an unloaded multi-agent v2 sub-agent through its parent; resume the parent first, or use thread/read to inspect it",+ )+ })?;++ let cold_resume_history = paginated_resume.then(|| thread_history.get_rollout_items());+ // Attach to the resolved child with only the caller's history-paging preferences.+ let attach_params = ThreadResumeParams {+ thread_id: child_thread_id.to_string(),+ exclude_turns,+ initial_turns_page,+ ..Default::default()+ };+ return match self+ .resume_running_thread(+ &request_id,+ &attach_params,+ app_server_client_name,+ app_server_client_version,+ cold_resume_history,+ )+ .await?+ {+ RunningThreadResumeResult::Handled => Ok(()),+ RunningThreadResumeResult::NotRunning(_) => Err(invalid_request(+ "cannot resume an unloaded multi-agent v2 sub-agent through its parent; resume the parent first, or use thread/read to inspect it",+ )),+ };+ }+let history_cwd = thread_history.session_cwd();let runtime_workspace_roots = runtime_workspace_roots.map(resolve_runtime_workspace_roots);let mut typesafe_overrides = self.build_thread_config_overrides(@@ -3954,6 +4000,7 @@ impl ThreadRequestProcessor {params: &ThreadResumeParams,app_server_client_name: Option<String>,app_server_client_version: Option<String>,+ cold_resume_history: Option<&[RolloutItem]>,) -> Result<RunningThreadResumeResult, JSONRPCErrorError> {let running_thread = if params.history.is_some() {if let Ok(existing_thread_id) = ThreadId::from_string(¶ms.thread_id)@@ -4029,7 +4076,14 @@ impl ThreadRequestProcessor {let is_running =matches!(existing_thread.agent_status().await, AgentStatus::Running);- if !has_subscribers && matches!(loaded_status, ThreadStatus::Idle) && !is_running {+ // Parent-owned V2 children must not be rebuilt from public resume overrides.+ if can_accept_direct_input(+ existing_thread.multi_agent_version(),+ &config_snapshot.session_source,+ ) && !has_subscribers+ && matches!(loaded_status, ThreadStatus::Idle)+ && !is_running+ {// A loaded idle thread is only a cache entry. Shut it down// before removing it so cold resume cannot duplicate a// thread that timed out during shutdown.@@ -4154,6 +4208,19 @@ impl ThreadRequestProcessor {} else {None};+ let cold_resume_token_usage_turn_id = cold_resume_history+ .map(|history| {+ let turns = paginated_turns+ .as_deref()+ .filter(|turns| !turns.is_empty())+ .unwrap_or_else(|| {+ paginated_initial_turns_page+ .as_ref()+ .map_or(&[][..], |page| page.data.as_slice())+ });+ restored_token_usage_turn_id(history, turns)+ })+ .filter(|turn_id| !turn_id.is_empty());let paginated_initial_turns_page_with_active_slot = if paginated_resume {match params.initial_turns_page.as_ref() {Some(params)@@ -4181,6 +4248,7 @@ impl ThreadRequestProcessor {Box::new(crate::thread_state::PendingThreadResumeRequest {request_id: request_id.clone(),history_items,+ cold_resume_token_usage_turn_id,config_snapshot,instruction_sources,thread_summary,diff --git a/codex-rs/app-server/src/thread_state.rs b/codex-rs/app-server/src/thread_state.rsindex 46dc35a36b..3795638cdd 100644--- a/codex-rs/app-server/src/thread_state.rs+++ b/codex-rs/app-server/src/thread_state.rs@@ -36,6 +36,8 @@ type PendingInterruptQueue = Vec<ConnectionRequestId>;pub(crate) struct PendingThreadResumeRequest {pub(crate) request_id: ConnectionRequestId,pub(crate) history_items: Vec<RolloutItem>,+ /// Usage attribution already resolved while cold-loading a paginated child.+ pub(crate) cold_resume_token_usage_turn_id: Option<String>,pub(crate) config_snapshot: ThreadConfigSnapshot,pub(crate) instruction_sources: Vec<LegacyAppPathString>,pub(crate) thread_summary: codex_app_server_protocol::Thread,diff --git a/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs b/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rsindex 65e1ce7d79..76f263532a 100644--- a/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs+++ b/codex-rs/app-server/tests/suite/v2/multi_agent_v2_developer_instructions.rs@@ -3,16 +3,39 @@ use app_test_support::MockResponsesConfig;use app_test_support::TestAppServer;use app_test_support::write_models_cache;use codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::JSONRPCMessage;+use codex_app_server_protocol::JSONRPCNotification;+use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::SandboxMode;+use codex_app_server_protocol::SandboxPolicy;+use codex_app_server_protocol::ThreadHistoryMode;+use codex_app_server_protocol::ThreadLoadedListParams;+use codex_app_server_protocol::ThreadLoadedListResponse;+use codex_app_server_protocol::ThreadReadParams;+use codex_app_server_protocol::ThreadReadResponse;use codex_app_server_protocol::ThreadResumeParams;use codex_app_server_protocol::ThreadResumeResponse;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;+use codex_app_server_protocol::ThreadStatus;+use codex_app_server_protocol::ThreadTokenUsageUpdatedNotification;+use codex_app_server_protocol::ThreadUnsubscribeParams;+use codex_app_server_protocol::ThreadUnsubscribeResponse;+use codex_app_server_protocol::ThreadUnsubscribeStatus;use codex_app_server_protocol::TurnStartParams;use codex_app_server_protocol::TurnStartResponse;+use codex_app_server_protocol::TurnStatus;use codex_app_server_protocol::UserInput;+use codex_protocol::ThreadId;+use codex_protocol::openai_models::ReasoningEffort;+use codex_protocol::protocol::SessionSource;+use codex_protocol::protocol::SubAgentSource;+use codex_state::StateRuntime;+use codex_utils_absolute_path::test_support::PathExt;use core_test_support::responses;use pretty_assertions::assert_eq;use serde_json::json;+use std::collections::HashMap;use std::time::Duration;use tempfile::TempDir;use test_case::test_case;@@ -38,13 +61,14 @@ const ROLE_INSTRUCTIONS: &str = "configured role developer instructions";#[test_case("explicit configured role"; "explicit configured role")]#[test_case("full history configured role"; "full history configured role")]#[test_case("implicit configured default"; "implicit configured default")]+#[test_case("bounded implicit configured default"; "bounded implicit configured default")]#[test_case("full fork skips default role"; "full fork skips default role")]#[tokio::test]async fn spawned_subagents_apply_configured_developer_instruction_precedence(case: &str,) -> Result<()> {let fork_turns = match case {- "bounded history" => Some("1"),+ "bounded history" | "bounded implicit configured default" => Some("1"),"no history" | "explicit configured role" | "implicit configured default" => Some("none"),_ => None,};@@ -57,7 +81,8 @@ async fn spawned_subagents_apply_configured_developer_instruction_precedence(let configured_override = match case {"unset override"| "full history configured role"- | "configured role without instructions" => None,+ | "configured role without instructions"+ | "bounded implicit configured default" => None,"blank override" => Some(" "),"full history" => Some(" child-only developer instructions "),_ => Some(CHILD_INSTRUCTIONS),@@ -73,6 +98,7 @@ async fn spawned_subagents_apply_configured_developer_instruction_precedence(| "explicit configured role"| "full history configured role"| "implicit configured default"+ | "bounded implicit configured default"| "full fork skips default role");let role_has_instructions = matches!(@@ -80,6 +106,7 @@ async fn spawned_subagents_apply_configured_developer_instruction_precedence("explicit configured role"| "full history configured role"| "implicit configured default"+ | "bounded implicit configured default"| "full fork skips default role");let expected = match case {@@ -87,7 +114,8 @@ async fn spawned_subagents_apply_configured_developer_instruction_precedence("blank override" => None,"explicit configured role"| "full history configured role"- | "implicit configured default" => Some(ROLE_INSTRUCTIONS),+ | "implicit configured default"+ | "bounded implicit configured default" => Some(ROLE_INSTRUCTIONS),_ => Some(CHILD_INSTRUCTIONS),};const PARENT_PROMPT: &str = "spawn the instruction override worker";@@ -448,24 +476,41 @@ async fn compacted_full_history_fork_replaces_parent_developer_instructions() ->Ok(())}-/// Cold root resume preserves inherited instructions or reapplies the configured v2 override.+/// Child attachment and owner-mediated cold resume preserve recorded instructions and parent authority.#[test_case(+ None,None,PARENT_INSTRUCTIONS,- CHILD_INSTRUCTIONS;+ ThreadHistoryMode::Legacy;"inherits parent developer instructions without an override")]#[test_case(Some(CHILD_INSTRUCTIONS),+ None,CHILD_INSTRUCTIONS,- PARENT_INSTRUCTIONS;+ ThreadHistoryMode::Legacy;"reapplies configured subagent developer instructions")]+#[test_case(+ Some(CHILD_INSTRUCTIONS),+ Some("custom"),+ ROLE_INSTRUCTIONS,+ ThreadHistoryMode::Paginated;+ "reapplies updated configured role settings and restores paginated usage"+)]+#[test_case(+ Some(CHILD_INSTRUCTIONS),+ Some("default"),+ ROLE_INSTRUCTIONS,+ ThreadHistoryMode::Legacy;+ "reapplies an implicitly selected configured default role"+)]#[tokio::test]-async fn cold_resume_preserves_effective_developer_instructions_for_roleless_worker(+async fn cold_resume_preserves_effective_developer_instructions_for_worker(configured_subagent_developer_instructions: Option<&str>,+ agent_type: Option<&str>,expected_developer_instructions: &str,- unexpected_developer_instructions: &str,+ history_mode: ThreadHistoryMode,) -> Result<()> {const INITIAL_PROMPT: &str = "spawn a durable instruction worker";const INITIAL_TASK: &str = "perform the initial durable instruction task";@@ -474,9 +519,49 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_worconst SPAWN_CALL_ID: &str = "spawn-durable-instruction-worker";const WAIT_CALL_ID: &str = "wait-for-durable-instruction-worker";const FOLLOWUP_CALL_ID: &str = "followup-durable-instruction-worker";+ const DIRECT_RESUME_INSTRUCTIONS: &str = "direct resume must not replace worker instructions";+ const COLD_RESUME_ERROR: &str = "cannot resume an unloaded multi-agent v2 sub-agent through its parent; resume the parent first, or use thread/read to inspect it";++ let instruction_markers = [+ PARENT_INSTRUCTIONS,+ CHILD_INSTRUCTIONS,+ ROLE_INSTRUCTIONS,+ DIRECT_RESUME_INSTRUCTIONS,+ ];+ let assert_developer_instructions = |request: &responses::ResponsesRequest, phase: &str| {+ let instruction_texts = request+ .message_input_texts("developer")+ .into_iter()+ .filter(|text| instruction_markers.contains(&text.as_str()))+ .collect::<Vec<_>>();+ assert_eq!(+ instruction_texts,+ vec![expected_developer_instructions.to_string()],+ "{phase} worker received unexpected developer instructions"+ );+ };+ let has_shell_tool = |request: &responses::ResponsesRequest| {+ let body = request.body_json();+ let tools = body["tools"].as_array().expect("model-visible tools");+ ["exec_command", "shell_command"].into_iter().any(|name| {+ tools.iter().any(|tool| tool["name"] == name)+ || responses::namespace_child_tool(&body, "functions", name).is_some()+ })+ };let server = responses::start_mock_server().await;- responses::mount_sse_once_match(+ let redirect_server = responses::start_mock_server().await;+ let redirect_base_url = format!("{}/v1", redirect_server.uri());+ let mut spawn_args = json!({+ "message": INITIAL_TASK,+ "task_name": "worker",+ "fork_turns": "none",+ "reasoning_effort": "low",+ });+ if let Some(agent_type) = agent_type.filter(|role| *role != "default") {+ spawn_args["agent_type"] = json!(agent_type);+ }+ let initial_parent_request = responses::mount_sse_once_match(&server,|request: &wiremock::Request| {String::from_utf8_lossy(&request.body).contains(INITIAL_PROMPT)@@ -487,11 +572,7 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_worSPAWN_CALL_ID,NAMESPACE,"spawn_agent",- &serde_json::to_string(&json!({- "message": INITIAL_TASK,- "task_name": "worker",- "fork_turns": "none",- }))?,+ &serde_json::to_string(&spawn_args)?,),responses::ev_completed("initial-parent-spawn"),]),@@ -506,7 +587,7 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_worresponses::sse(vec![responses::ev_response_created("initial-child-work"),responses::ev_assistant_message("initial-child-message", "initial child complete"),- responses::ev_completed("initial-child-work"),+ responses::ev_completed_with_tokens("initial-child-work", /*total_tokens*/ 150),]),).await;@@ -534,21 +615,35 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_wor).await;- let feature_config = match configured_subagent_developer_instructions {+ let mut feature_config = match configured_subagent_developer_instructions {Some(instructions) => format!("[features.multi_agent_v2]\nenabled = true\nsubagent_developer_instructions = {instructions:?}"),None => "[features.multi_agent_v2]\nenabled = true".to_string(),};let codex_home = TempDir::new()?;+ let role_path = codex_home.path().join("worker.toml");+ if let Some(agent_type) = agent_type {+ std::fs::write(+ &role_path,+ format!(+ "developer_instructions = {ROLE_INSTRUCTIONS:?}\nmodel_reasoning_effort = \"low\"\nfeatures.shell_tool = false\n"+ ),+ )?;+ feature_config.push_str(&format!(+ "\n\n[agents.{agent_type}]\ndescription = \"configured role\"\nconfig_file = \"./worker.toml\""+ ));+ }MockResponsesConfig::new(&server.uri()).with_model("gpt-5.4")- .with_root_config(&format!("developer_instructions = {PARENT_INSTRUCTIONS:?}"))+ .with_root_config(&format!(+ "developer_instructions = {PARENT_INSTRUCTIONS:?}\nmodel_reasoning_effort = \"high\""+ )).with_extra_config(&feature_config).write(codex_home.path())?;write_models_cache(codex_home.path())?;- let thread_id = {+ let (thread_id, child_resume_params, baseline) = {let mut app_server = TestAppServer::builder().with_codex_home(codex_home.path()).build_initialized()@@ -556,6 +651,7 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_worlet ThreadStartResponse { thread, .. } = app_server.start_thread(ThreadStartParams {model: Some("gpt-5.4".to_string()),+ history_mode: Some(history_mode),..Default::default()}).await?;@@ -576,27 +672,95 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_wor.into_iter().find(|request| !request.inputs_of_type("agent_message").is_empty()).expect("initial worker model request");- let developer_texts = initial_child_request.message_input_texts("developer");- assert!(- developer_texts- .iter()- .any(|text| text == expected_developer_instructions),- "initial worker lost its effective developer instructions: {developer_texts:?}"- );- assert!(- developer_texts- .iter()- .all(|text| text != unexpected_developer_instructions),- "initial worker received the wrong developer instructions: {developer_texts:?}"+ assert_developer_instructions(&initial_child_request, "initial");+ assert_eq!(+ initial_child_request.body_json()["reasoning"]["effort"],+ json!("low"));+ if agent_type.is_some() {+ assert!(has_shell_tool(&initial_parent_request.single_request()));+ assert!(!has_shell_tool(&initial_child_request));+ }+ let child_thread_id = initial_child_request+ .header("thread-id")+ .expect("initial worker thread ID");+ let baseline: ThreadResumeResponse = app_server+ .request(|request_id| ClientRequest::ThreadResume {+ request_id,+ params: ThreadResumeParams {+ thread_id: child_thread_id.clone(),+ exclude_turns: true,+ ..Default::default()+ },+ })+ .await?;+ assert_eq!(baseline.thread.id, child_thread_id);+ assert_eq!(baseline.thread.status, ThreadStatus::Idle);+ assert_eq!(baseline.thread.can_accept_direct_input, Some(false));+ assert_eq!(baseline.thread.agent_role.as_deref(), agent_type);+ assert_eq!(baseline.model_provider, "mock_provider");+ assert!(matches!(&baseline.sandbox, SandboxPolicy::ReadOnly { .. }));+ assert_eq!(baseline.reasoning_effort, Some(ReasoningEffort::Low));++ let unsubscribed: ThreadUnsubscribeResponse = app_server+ .request(|request_id| ClientRequest::ThreadUnsubscribe {+ request_id,+ params: ThreadUnsubscribeParams {+ thread_id: child_thread_id.clone(),+ },+ })+ .await?;+ assert_eq!(unsubscribed.status, ThreadUnsubscribeStatus::Unsubscribed);+ let loaded: ThreadLoadedListResponse = app_server+ .request(|request_id| ClientRequest::ThreadLoadedList {+ request_id,+ params: ThreadLoadedListParams::default(),+ })+ .await?;+ assert!(loaded.data.contains(&child_thread_id));++ let child_resume_params = ThreadResumeParams {+ thread_id: child_thread_id,+ model_provider: Some("mock_provider".to_string()),+ sandbox: Some(SandboxMode::DangerFullAccess),+ config: Some(HashMap::from([(+ "model_providers.mock_provider.base_url".to_string(),+ json!(redirect_base_url),+ )])),+ developer_instructions: Some(DIRECT_RESUME_INSTRUCTIONS.to_string()),+ exclude_turns: true,+ ..Default::default()+ };+ let reattached: ThreadResumeResponse = app_server+ .request(|request_id| ClientRequest::ThreadResume {+ request_id,+ params: child_resume_params.clone(),+ })+ .await?;+ assert_eq!(reattached, baseline);let shutdown = timeout(READ_TIMEOUT, app_server.shutdown_gracefully()).await??;assert!(shutdown.success(),"initial app-server shutdown failed: {shutdown}");- thread.id+ (thread.id, child_resume_params, baseline)};+ if agent_type.is_some() {+ std::fs::write(+ &role_path,+ format!(+ r#"developer_instructions = {ROLE_INSTRUCTIONS:?}+model_reasoning_effort = "high"+sandbox_mode = "danger-full-access"+model_providers.mock_provider.name = "Untrusted role provider"+model_providers.mock_provider.base_url = {redirect_base_url:?}+features.shell_tool = false+"#+ ),+ )?;+ }+responses::mount_sse_once_match(&server,|request: &wiremock::Request| {@@ -648,7 +812,39 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_wor.with_codex_home(codex_home.path()).build_initialized().await?;- let _: ThreadResumeResponse = app_server+ let child_thread_id = child_resume_params.thread_id.clone();+ let child_by_path = ThreadResumeParams {+ thread_id: ThreadId::new().to_string(),+ path: Some(baseline.thread.path.clone().expect("worker rollout path")),+ ..child_resume_params.clone()+ };+ for params in [child_resume_params.clone(), child_by_path.clone()] {+ let request_id = app_server.send_thread_resume_request(params).await?;+ let error = timeout(+ READ_TIMEOUT,+ app_server.read_stream_until_error_message(RequestId::Integer(request_id)),+ )+ .await??;+ assert_eq!(+ serde_json::to_value(error.error)?,+ json!({"code": -32600, "message": COLD_RESUME_ERROR})+ );+ }+ let stored_child: ThreadReadResponse = app_server+ .request(|request_id| ClientRequest::ThreadRead {+ request_id,+ params: ThreadReadParams {+ thread_id: child_thread_id.clone(),+ include_turns: true,+ },+ })+ .await?;+ assert_eq!(stored_child.thread.id, child_thread_id);+ assert_eq!(stored_child.thread.status, ThreadStatus::NotLoaded);+ assert_eq!(stored_child.thread.agent_role.as_deref(), agent_type);+ assert!(!stored_child.thread.turns.is_empty());++ let resumed_parent: ThreadResumeResponse = app_server.request(|request_id| ClientRequest::ThreadResume {request_id,params: ThreadResumeParams {@@ -657,6 +853,126 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_wor},}).await?;+ assert_eq!(resumed_parent.reasoning_effort, Some(ReasoningEffort::High));+ let loaded: ThreadLoadedListResponse = app_server+ .request(|request_id| ClientRequest::ThreadLoadedList {+ request_id,+ params: ThreadLoadedListParams::default(),+ })+ .await?;+ assert!(loaded.data.contains(&thread_id));+ assert!(!loaded.data.contains(&child_thread_id));++ let mut expected = baseline;+ if history_mode == ThreadHistoryMode::Paginated {+ let state_db = StateRuntime::init(+ codex_state::SqliteConfig::new_for_testing(codex_home.path().abs()),+ "mock_provider".into(),+ )+ .await?;+ let mut metadata = state_db+ .get_thread(ThreadId::from_string(&child_thread_id)?)+ .await?+ .expect("worker metadata");+ let mut source: SessionSource = serde_json::from_str(&metadata.source)?;+ let SessionSource::SubAgent(SubAgentSource::ThreadSpawn {+ parent_thread_id, ..+ }) = &mut source+ else {+ anyhow::bail!("expected worker thread-spawn source");+ };+ // Stale display metadata must not choose which parent controls the resume.+ *parent_thread_id = ThreadId::new();+ metadata.source = serde_json::to_string(&source)?;+ state_db.upsert_thread(&metadata).await?;+ expected.thread.source = source.into();+ }++ let is_child_usage = |notification: &JSONRPCNotification| {+ notification.method == "thread/tokenUsage/updated"+ && notification+ .params+ .as_ref()+ .is_some_and(|params| params["threadId"].as_str() == Some(child_thread_id.as_str()))+ };+ let resume_id = app_server.send_thread_resume_request(child_by_path).await?;+ let resumed: ThreadResumeResponse = timeout(READ_TIMEOUT, async {+ loop {+ match app_server.read_next_message().await? {+ JSONRPCMessage::Response(response)+ if response.id == RequestId::Integer(resume_id) =>+ {+ break app_test_support::to_response(response);+ }+ JSONRPCMessage::Notification(notification) => assert!(+ !is_child_usage(¬ification),+ "child usage replay must follow the resume response"+ ),+ JSONRPCMessage::Error(error) => anyhow::bail!("unexpected error: {error:?}"),+ JSONRPCMessage::Request(_) | JSONRPCMessage::Response(_) => {}+ }+ }+ })+ .await??;+ if history_mode == ThreadHistoryMode::Paginated {+ assert_eq!(resumed.thread.history_mode, history_mode);+ assert!(resumed.thread.turns.is_empty());+ let replay = timeout(+ READ_TIMEOUT,+ app_server+ .read_stream_until_matching_notification("child usage replay", &is_child_usage),+ )+ .await??;+ let replay: ThreadTokenUsageUpdatedNotification =+ serde_json::from_value(replay.params.expect("usage parameters"))?;+ let saved_turn = stored_child.thread.turns.last().expect("saved child turn");+ assert_eq!(saved_turn.status, TurnStatus::Completed);+ assert_eq!(+ (replay.turn_id, replay.token_usage.total.total_tokens),+ (saved_turn.id.clone(), 150),+ );+ let warm: ThreadResumeResponse = app_server+ .request(|request_id| ClientRequest::ThreadResume {+ request_id,+ params: child_resume_params,+ })+ .await?;+ assert!(warm.thread.turns.is_empty());+ assert!(+ timeout(+ Duration::from_millis(100),+ app_server+ .read_stream_until_matching_notification("child usage replay", &is_child_usage),+ )+ .await+ .is_err(),+ "warm metadata-only child resume should not replay token usage"+ );+ }+ let expected_reasoning_effort = if agent_type.is_some() {+ ReasoningEffort::High+ } else {+ ReasoningEffort::Low+ };+ assert_eq!(+ resumed.reasoning_effort,+ Some(expected_reasoning_effort.clone())+ );+ let authority = |response: ThreadResumeResponse| {+ (+ response.thread.id,+ response.thread.parent_thread_id,+ response.thread.source,+ response.thread.status,+ response.thread.can_accept_direct_input,+ response.model_provider,+ response.sandbox,+ response.approval_policy,+ response.approvals_reviewer,+ response.active_permission_profile,+ )+ };+ assert_eq!(authority(resumed), authority(expected));let _: TurnStartResponse = app_server.request(|request_id| ClientRequest::TurnStart {request_id,@@ -676,13 +992,7 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_wor.requests().into_iter().find(|request| {- request- .inputs_of_type("agent_message")- .iter()- .any(|message| {- message.get("recipient").and_then(serde_json::Value::as_str)- == Some("/root/worker")- })+ request.header("thread-id").as_deref() == Some(child_thread_id.as_str())&& request.body_contains_text(FOLLOWUP_TASK)}){@@ -693,18 +1003,21 @@ async fn cold_resume_preserves_effective_developer_instructions_for_roleless_wor}).await?;- let developer_texts = resumed_child_request.message_input_texts("developer");- assert!(- developer_texts- .iter()- .any(|text| text == expected_developer_instructions),- "resumed worker lost its effective developer instructions: {developer_texts:?}"+ assert_eq!(+ resumed_child_request.body_json()["reasoning"]["effort"],+ json!(expected_reasoning_effort));+ if agent_type.is_some() {+ assert!(!has_shell_tool(&resumed_child_request));+ }+ assert_developer_instructions(&resumed_child_request, "resumed");assert!(- developer_texts- .iter()- .all(|text| text != unexpected_developer_instructions),- "resumed worker received the wrong developer instructions: {developer_texts:?}"+ redirect_server+ .received_requests()+ .await+ .expect("redirect mock requests")+ .is_empty(),+ "caller or role config redirected the owner-restored child");Ok(())diff --git a/codex-rs/app-server/tests/suite/v2/thread_list.rs b/codex-rs/app-server/tests/suite/v2/thread_list.rsindex 62e228e464..32af51abdb 100644--- a/codex-rs/app-server/tests/suite/v2/thread_list.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_list.rs@@ -35,6 +35,7 @@ use codex_app_server_protocol::TurnStartParams;use codex_app_server_protocol::TurnStartResponse;use codex_app_server_protocol::UserInput;use codex_core::ARCHIVED_SESSIONS_SUBDIR;+use codex_features::Feature;use codex_git_utils::GitSha;use codex_protocol::ThreadId;use codex_protocol::protocol::GitInfo as CoreGitInfo;@@ -1299,7 +1300,10 @@ async fn thread_list_empty_source_kinds_defaults_to_interactive_only() -> Resultasync fn thread_list_reports_loaded_subagent_direct_input_capability() -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;let codex_home = TempDir::new()?;- MockResponsesConfig::new(&server.uri()).write(codex_home.path())?;+ MockResponsesConfig::new(&server.uri())+ .disable_feature(Feature::MultiAgentV2)+ .enable_feature(Feature::Collab)+ .write(codex_home.path())?;let cli_id = create_fake_rollout(codex_home.path(),"2025-02-01T09-00-00",@@ -1309,33 +1313,46 @@ async fn thread_list_reports_loaded_subagent_direct_input_capability() -> Result/*git_info*/ None,)?;let parent_thread_id = ThreadId::from_string(&cli_id)?;+ let parent_rollout_path = rollout_path(codex_home.path(), "2025-02-01T09-00-00", &cli_id);+ let mut parent_meta = read_session_meta_line(&parent_rollout_path).await?;+ parent_meta.meta.multi_agent_version = Some(MultiAgentVersion::V2);+ append_rollout_item_to_path(&parent_rollout_path, &RolloutItem::SessionMeta(parent_meta))+ .await?;+ // Legacy children resume before the root restores the V2 registry from persisted spawn edges.let mut expected = vec![(cli_id.clone(), None, false)];- let mut threads_to_resume = vec![cli_id.clone()];+ let mut threads_to_resume = vec![(cli_id.clone(), SessionSource::Cli, Some(true))];for (filename_ts, timestamp, version, capability, should_resume) in [("2025-02-01T10-00-00","2025-02-01T10:00:00Z",- MultiAgentVersion::V1,+ Some(MultiAgentVersion::V1),+ Some(true),+ true,+ ),+ (+ "2025-02-01T10-30-00",+ "2025-02-01T10:30:00Z",+ None,Some(true),true,),("2025-02-01T11-00-00","2025-02-01T11:00:00Z",- MultiAgentVersion::V2,+ Some(MultiAgentVersion::V2),Some(false),true,),("2025-02-01T12-00-00","2025-02-01T12:00:00Z",- MultiAgentVersion::V2,+ Some(MultiAgentVersion::V2),None,false,),] {- let thread_id = create_fake_rollout_with_source(+ let thread_id = create_fake_parented_rollout_with_source(codex_home.path(),filename_ts,timestamp,@@ -1349,27 +1366,41 @@ async fn thread_list_reports_loaded_subagent_direct_input_capability() -> Resultagent_nickname: None,agent_role: None,}),+ parent_thread_id.into(),+ parent_thread_id,)?;let path = rollout_path(codex_home.path(), filename_ts, &thread_id);let mut session_meta = read_session_meta_line(&path).await?;- session_meta.meta.multi_agent_version = Some(version);- append_rollout_item_to_path(&path, &RolloutItem::SessionMeta(session_meta)).await?;+ let source = SessionSource::from(session_meta.meta.source.clone());+ if let Some(version) = version {+ session_meta.meta.multi_agent_version = Some(version);+ append_rollout_item_to_path(&path, &RolloutItem::SessionMeta(session_meta)).await?;+ }if should_resume {- threads_to_resume.push(thread_id.clone());+ let resume = (thread_id.clone(), source, capability);+ if version == Some(MultiAgentVersion::V2) {+ threads_to_resume.push(resume);+ } else {+ threads_to_resume.insert(/*index*/ 0, resume);+ }}expected.push((thread_id, capability, !should_resume));}let mut mcp = init_mcp(codex_home.path()).await?;- for thread_id in threads_to_resume {+ for (thread_id, source, capability) in threads_to_resume {let request_id = mcp.send_thread_resume_request(ThreadResumeParams {- thread_id,+ thread_id: thread_id.clone(),..Default::default()}).await?;- let _: ThreadResumeResponse =+ let ThreadResumeResponse { thread, .. } =timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(request_id)).await??;+ assert_eq!(+ (thread.id, thread.source, thread.can_accept_direct_input),+ (thread_id, source, capability)+ );}let response = list_threads(diff --git a/codex-rs/core/src/agent/control/residency_tests.rs b/codex-rs/core/src/agent/control/residency_tests.rsindex 75afdd45cd..d5d58b42a1 100644--- a/codex-rs/core/src/agent/control/residency_tests.rs+++ b/codex-rs/core/src/agent/control/residency_tests.rs@@ -114,7 +114,7 @@ async fn interrupted_v2_agent_is_lost_after_residency_eviction() {mark_thread_completed(second.thread.as_ref()).await;let err = control- .ensure_v2_agent_loaded(config, first.thread_id)+ .ensure_v2_agent_loaded(config, first.thread_id, /*parent*/ None).await.expect_err("evicted interrupted agent should stay lost");match err.details() {diff --git a/codex-rs/core/src/agent/control/spawn.rs b/codex-rs/core/src/agent/control/spawn.rsindex 727f883980..ca6e43bc05 100644--- a/codex-rs/core/src/agent/control/spawn.rs+++ b/codex-rs/core/src/agent/control/spawn.rs@@ -1,6 +1,7 @@use super::residency::is_v2_resident_session_source;use super::*;use crate::agent::role::apply_role_to_config;+use crate::codex_thread::CodexThread;use crate::config::PermissionProfileSnapshot;use crate::context::ContextualUserFragment;use crate::context::CurrentTimeReminder;@@ -9,9 +10,13 @@ use crate::context::ManagedDeveloperInstructions;use crate::context::MultiAgentModeInstructions;use crate::context::MultiAgentRoleInstructions;use crate::session::multi_agents::resolve_usage_hints;+use crate::tools::handlers::multi_agents_common::build_agent_resume_config;use codex_context_fragments::set_annotated_content;use codex_context_fragments::to_annotated_content;use codex_extension_api::ExtensionDataInit;+use codex_protocol::intersect_effective_permission_profiles;+use codex_protocol::protocol::EnvironmentConfigState;+use codex_utils_path_uri::PathUri;const AGENT_NAMES: &str = include_str!("../agent_names.txt");@@ -267,20 +272,65 @@ impl AgentControl {.await}+ fn validate_loaded_v2_child(+ &self,+ thread: &CodexThread,+ parent_thread_id: ThreadId,+ ) -> CodexResult<()> {+ if thread.is_running()+ && thread.multi_agent_version() == Some(MultiAgentVersion::V2)+ && thread.session_source.parent_thread_id() == Some(parent_thread_id)+ && Arc::ptr_eq(&self.state, &thread.session.services.agent_control.state)+ {+ return Ok(());+ }+ Err(CodexErr::InvalidRequest(format!(+ "multi-agent v2 child {} is not owned by its loaded parent",+ thread.session.thread_id+ )))+ }++ /// A provided parent enables owner-validated reloads; `None` preserves sender-driven reloads.pub(crate) async fn ensure_v2_agent_loaded(&self,mut config: Config,thread_id: ThreadId,+ parent: Option<Arc<CodexThread>>,) -> CodexResult<()> {let state = self.upgrade()?;- if state.get_thread(thread_id).await.is_ok() {+ let parent = if let Some(parent) = parent {+ let parent_thread_id = parent.session.thread_id;+ let turn = parent.session.new_default_turn().await;+ config = build_agent_resume_config(&turn).map_err(|_| {+ CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {thread_id} with the current parent settings"+ ))+ })?;+ let registered_parent = state.get_thread(parent_thread_id).await.ok();+ if !registered_parent+ .as_ref()+ .is_some_and(|registered| Arc::ptr_eq(registered, &parent))+ || !parent.is_running()+ || parent.multi_agent_version() != Some(MultiAgentVersion::V2)+ || !Arc::ptr_eq(&self.state, &parent.session.services.agent_control.state)+ {+ return Err(CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {thread_id}: parent ownership is unavailable; resume the parent first"+ )));+ }+ Some((parent, turn.environments.clone()))+ } else {+ None+ };+ let owner_thread_id = parent.as_ref().map(|(parent, _)| parent.session.thread_id);+ if owner_thread_id.is_none() && state.get_thread(thread_id).await.is_ok() {self.touch_loaded_v2_residency(&state, thread_id).await;return Ok(());}if self.state.agent_metadata_for_thread(thread_id).is_none() {return Err(CodexErr::ThreadNotFound(thread_id));}- let environment_selections = self.state.evicted_environments(thread_id);+ let mut environment_selections = self.state.evicted_environments(thread_id);let stored_thread = state.read_stored_thread(ReadThreadParams {@@ -291,6 +341,7 @@ impl AgentControl {.await?;let stored_model = stored_thread.model.clone();let stored_model_provider = stored_thread.model_provider.clone();+ let stored_reasoning_effort = stored_thread.reasoning_effort.clone();let stored_source = stored_thread.source.clone();let stored_parent_thread_id = stored_thread.parent_thread_id;let history = load_agent_model_context(&state, thread_id, stored_thread.history_mode)@@ -307,6 +358,25 @@ impl AgentControl {let (session_source, _) = initial_history.get_resumed_session_sources().unwrap_or((stored_source, None));+ if let Some(parent_thread_id) = owner_thread_id {+ if session_source.parent_thread_id() != Some(parent_thread_id)+ || initial_history+ .get_resumed_parent_thread_id()+ .is_some_and(|recorded_parent| recorded_parent != parent_thread_id)+ || stored_parent_thread_id+ .is_some_and(|recorded_parent| recorded_parent != parent_thread_id)+ {+ return Err(CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {thread_id}: recorded parent ownership is inconsistent"+ )));+ }+ if let Ok(thread) = state.get_thread(thread_id).await {+ self.validate_loaded_v2_child(&thread, parent_thread_id)?;+ self.touch_loaded_v2_residency(&state, thread_id).await;+ return Ok(());+ }+ }+ config.model_reasoning_effort = stored_reasoning_effort;if let Some(role_name) = session_source.get_agent_role() {let runtime_approval_policy = config.permissions.approval_policy.value();let runtime_approvals_reviewer = config.approvals_reviewer;@@ -358,20 +428,118 @@ impl AgentControl {})?;config.model_provider_id = stored_model_provider;}+ let parent_thread_id = owner_thread_id+ .or_else(|| initial_history.get_resumed_parent_thread_id())+ .or(stored_parent_thread_id);+ let (inherited_environments, inherited_exec_policy, client_mcp_extensions) = if let Some(+ (parent, parent_environments),+ ) =+ parent.as_ref()+ {+ let parent_config = parent.session.get_config().await;+ if !crate::exec_policy::child_uses_parent_exec_policy(&parent_config, &config) {+ return Err(CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {thread_id}: parent execution policy has changed; retry through the parent"+ )));+ }+ if let Some(selections) = environment_selections.as_mut() {+ for selection in selections {+ let environment_id = &selection.environment_id;+ let invalid_environment = |reason: &str| {+ CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {thread_id}: cached environment {environment_id} {reason}"+ ))+ };+ // Matching the attachment also keeps startup on the captured owner executor.+ let owner_environment = parent_environments+ .turn_environments()+ .find(|environment| {+ environment.selection.environment_id == *environment_id+ && environment.cwd() == &selection.cwd+ && environment.workspace_roots()+ == selection.workspace_roots.as_slice()+ })+ .ok_or_else(|| {+ invalid_environment("no longer matches a ready parent environment")+ })?;+ let owner_config = owner_environment.config();+ let child_config = match &selection.config {+ EnvironmentConfigState::FromThread => {+ // Pin current owner authority instead of re-inferring child settings.+ selection.config = EnvironmentConfigState::Ready(owner_config.clone());+ continue;+ }+ EnvironmentConfigState::Ready(config) => config,+ EnvironmentConfigState::Pending | EnvironmentConfigState::Failed(_) => {+ return Err(invalid_environment("configuration is not ready"));+ }+ };+ let mut bounded_config = child_config.clone();+ bounded_config.permission_profile = owner_config.permission_profile.clone();+ if bounded_config != *owner_config {+ return Err(invalid_environment(+ "configuration differs from the current parent",+ ));+ }+ if child_config.permission_profile == owner_config.permission_profile {+ continue;+ }+ if owner_environment.environment.is_remote() {+ return Err(invalid_environment(+ "permissions changed on a remote executor",+ ));+ }+ let cwd = selection.cwd.to_abs_path().map_err(|_| {+ invalid_environment("working directory is not a local absolute path")+ })?;+ let roots = selection+ .workspace_roots+ .iter()+ .map(PathUri::to_abs_path)+ .collect::<Result<Vec<_>, _>>()+ .map_err(|_| {+ invalid_environment("workspace roots are not local absolute paths")+ })?;+ let authority = owner_environment+ .permission_profile()+ .clone()+ .materialize_project_roots_with_workspace_roots(&roots);+ let requested = child_config+ .permission_profile+ .permission_profile()+ .clone()+ .materialize_project_roots_with_workspace_roots(&roots);+ let permissions =+ intersect_effective_permission_profiles(&authority, &requested, &cwd)+ .map_err(|err| {+ invalid_environment(&format!(+ "permissions cannot be intersected safely: {err}"+ ))+ })?;+ bounded_config.permission_profile =+ PermissionProfileSnapshot::legacy(permissions);+ selection.config = EnvironmentConfigState::Ready(bounded_config);+ }+ }+ (+ Some(parent_environments.clone()),+ Some(Arc::clone(&parent.session.services.exec_policy)),+ Some(parent.client_mcp_extensions()),+ )+ } else {+ (+ self.inherited_environments_for_source(&state, Some(&session_source))+ .await,+ self.inherited_exec_policy_for_source(&state, Some(&session_source), &config)+ .await,+ None,+ )+ };+ // Reserving a slot can evict an idle nested parent. Keep its authority captured above.let residency_slot = self.reserve_v2_residency_slot(&state, &config, Some(thread_id)).await?;- let parent_thread_id = initial_history- .get_resumed_parent_thread_id()- .or(stored_parent_thread_id);- let inherited_environments = self- .inherited_environments_for_source(&state, Some(&session_source))- .await;- let inherited_exec_policy = self- .inherited_exec_policy_for_source(&state, Some(&session_source), &config)- .await;-match state.resume_thread_with_history_with_source(ResumeThreadWithHistoryOptions {config,@@ -382,17 +550,24 @@ impl AgentControl {environment_selections,inherited_environments,inherited_exec_policy,+ client_mcp_extensions,}).await{Ok(reloaded_thread) => {+ if let Some(parent_thread_id) = owner_thread_id {+ self.validate_loaded_v2_child(&reloaded_thread.thread, parent_thread_id)?;+ }self.state.clear_evicted_environments(thread_id);residency_slot.commit(reloaded_thread.thread_id);state.notify_thread_created(reloaded_thread.thread_id);Ok(())}Err(err) => {- if state.get_thread(thread_id).await.is_ok() {+ if let Ok(thread) = state.get_thread(thread_id).await {+ if let Some(parent_thread_id) = owner_thread_id {+ self.validate_loaded_v2_child(&thread, parent_thread_id)?;+ }self.state.clear_evicted_environments(thread_id);drop(residency_slot);self.touch_loaded_v2_residency(&state, thread_id).await;@@ -1042,6 +1217,7 @@ impl AgentControl {environment_selections: None,inherited_environments,inherited_exec_policy,+ client_mcp_extensions: None,}).await?;let mut agent_metadata = agent_metadata;diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rsindex f836e9324b..1ddc5c8875 100644--- a/codex-rs/core/src/agent/control_tests.rs+++ b/codex-rs/core/src/agent/control_tests.rs@@ -3,6 +3,7 @@ use crate::CodexThread;use crate::StateDbHandle;use crate::ThreadManager;use crate::agent::agent_status_from_event;+use crate::agent::next_thread_spawn_depth;use crate::agent_communication::AgentCommunicationContext;use crate::agent_communication::AgentCommunicationKind;use crate::config::AgentRoleConfig;@@ -14,6 +15,7 @@ use crate::context::MultiAgentRoleInstructions;use crate::context::SubagentNotification;use crate::init_state_db;use crate::thread_manager::StartThreadOptions;+use crate::tools::handlers::multi_agents_common::thread_spawn_source;use assert_matches::assert_matches;use codex_extension_api::ExtensionDataInit;use codex_extension_api::empty_extension_registry;@@ -34,6 +36,8 @@ use codex_protocol::config_types::Settings;use codex_protocol::error::CodexErrorDetails;use codex_protocol::items::TurnItem;use codex_protocol::items::UserMessageItem;+use codex_protocol::mcp::ClientMcpExtensions;+use codex_protocol::mcp::OPENAI_FORM_EXTENSION_ID;use codex_protocol::models::ContentItem;use codex_protocol::models::ContentItemKind;use codex_protocol::models::FunctionCallOutputPayload;@@ -42,6 +46,7 @@ use codex_protocol::models::MessagePhase;use codex_protocol::models::PermissionProfile;use codex_protocol::models::ResponseItem;use codex_protocol::protocol::AskForApproval;+use codex_protocol::protocol::EnvironmentConfigState;use codex_protocol::protocol::ErrorEvent;use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::InterAgentCommunication;@@ -706,34 +711,99 @@ async fn send_inter_agent_communication_without_turn_queues_message_without_trig#[tokio::test]async fn ensure_v2_agent_loaded_reloads_registered_unloaded_agent() {- let (home, mut config) = test_config().await;- let _ = config.features.enable(Feature::MultiAgentV2);- let _ = config.features.enable(Feature::Sqlite);- config.model = Some("gpt-5.6-sol".to_string());- let harness = AgentControlHarness::new_with_config(home, config).await;- let (parent_thread_id, _parent_thread) = harness.start_paginated_thread().await;- let agent_path = AgentPath::try_from("/root/worker").expect("agent path");- let mut child_config = harness.config.clone();- child_config.model = Some("gpt-5.6-luna".to_string());- let spawned_agent = harness- .control+ check_v2_agent_reload(V2ReloadRoute::Sender).await;+}++#[tokio::test]+async fn ensure_v2_child_loaded_preserves_evicted_parent_authority() {+ check_v2_agent_reload(V2ReloadRoute::NestedParent).await;+}++#[derive(Clone, Copy)]+enum V2ReloadRoute {+ Sender,+ NestedParent,+}++async fn spawn_v2_reload_test_child(+ control: &AgentControl,+ config: Config,+ parent: &CodexThread,+ task_name: &str,+) -> LiveAgent {+ let source = thread_spawn_source(+ parent.session.thread_id,+ &parent.session_source,+ next_thread_spawn_depth(&parent.session_source),+ /*agent_role*/ None,+ Some(task_name.to_string()),+ )+ .expect("child source");+ control.spawn_agent_with_metadata(- child_config,+ config,text_input("hello child"),- Some(SessionSource::SubAgent(SubAgentSource::ThreadSpawn {- parent_thread_id,- depth: 1,- agent_path: Some(agent_path.clone()),- agent_nickname: None,- agent_role: None,- })),+ Some(source),SpawnAgentOptions {- parent_thread_id: Some(parent_thread_id),+ parent_thread_id: Some(parent.session.thread_id),..Default::default()},).await- .expect("spawn_agent should succeed");+ .expect("spawn_agent should succeed")+}++async fn check_v2_agent_reload(route: V2ReloadRoute) {+ let (home, mut config) = test_config().await;+ let _ = config.features.enable(Feature::MultiAgentV2);+ let _ = config.features.enable(Feature::Sqlite);+ config.model = Some("gpt-5.6-sol".to_string());+ config.multi_agent_v2.max_concurrent_threads_per_session = 3;+ config.permissions.allow_login_shell = true;+ config+ .permissions+ .set_permission_profile(PermissionProfile::read_only())+ .expect("read-only parent profile");+ let harness = AgentControlHarness::new_with_config(home, config).await;+ let client_mcp_extensions =+ ClientMcpExtensions::new([(OPENAI_FORM_EXTENSION_ID.to_string(), serde_json::json!({}))]);+ let root = harness+ .manager+ .start_thread(StartThreadOptions {+ history_mode: Some(ThreadHistoryMode::Paginated),+ client_mcp_extensions: client_mcp_extensions.clone(),+ ..StartThreadOptions::new(harness.config.clone())+ })+ .await+ .expect("start root thread");+ let control = root.thread.session.services.agent_control.clone();+ let parent_thread = match route {+ V2ReloadRoute::Sender => root.thread,+ V2ReloadRoute::NestedParent => {+ let parent = spawn_v2_reload_test_child(+ &control,+ harness.config.clone(),+ &root.thread,+ "parent",+ )+ .await;+ harness+ .manager+ .get_thread(parent.thread_id)+ .await+ .expect("nested parent should exist")+ }+ };+ let parent_thread_id = parent_thread.session.thread_id;+ let mut child_config = harness.config.clone();+ child_config.model = Some("gpt-5.6-luna".to_string());+ let spawned_agent =+ spawn_v2_reload_test_child(&control, child_config, &parent_thread, "worker").await;+ let agent_path = spawned_agent+ .metadata+ .agent_path+ .clone()+ .expect("agent path");let child_thread = harness.manager.get_thread(spawned_agent.thread_id)@@ -781,16 +851,68 @@ async fn ensure_v2_agent_loaded_reloads_registered_unloaded_agent() {.cloned().expect("ollama provider should be configured");- harness- .control- .ensure_v2_agent_loaded(sender_config, spawned_agent.thread_id)- .await- .expect("known v2 agent should reload");+ let mut parent_turn = parent_thread.session.new_default_turn().await;+ match route {+ V2ReloadRoute::Sender => control+ .ensure_v2_agent_loaded(sender_config, spawned_agent.thread_id, /*parent*/ None)+ .await+ .expect("known v2 agent should reload"),+ V2ReloadRoute::NestedParent => {+ let environment = parent_turn+ .environments+ .primary()+ .expect("parent environment");+ let thread_config = environment.config().clone();+ let mut owner_config = thread_config.clone();+ owner_config.allow_login_shell = false;+ let mut selection = environment.selection();+ selection.config = EnvironmentConfigState::Ready(owner_config);+ parent_thread+ .session+ .services+ .turn_environments+ .update_selections(std::slice::from_ref(&selection), &thread_config);+ parent_turn = parent_thread.session.new_default_turn().await;+ parent_thread.session.mark_interrupted();+ // The fixture has no task runner to finish the turn or consume child results.+ *parent_thread.session.active_turn.lock().await = None;+ let _ = parent_thread+ .session+ .input_queue+ .drain_mailbox_input_items()+ .await;+ harness+ .manager+ .ensure_multi_agent_v2_child_loaded(spawned_agent.thread_id)+ .await+ .expect("known child should reload through its parent");+ assert!(harness.manager.get_thread(parent_thread_id).await.is_err());+ }+ }let reloaded_child = harness.manager.get_thread(spawned_agent.thread_id).await.expect("reloaded child thread should exist");+ if matches!(route, V2ReloadRoute::NestedParent) {+ let reloaded_turn = reloaded_child.session.new_default_turn().await;+ assert_eq!(+ (+ reloaded_turn.environments.to_selections(),+ reloaded_turn.permission_profile(),+ reloaded_child.client_mcp_extensions(),+ ),+ (+ parent_turn.environments.to_selections(),+ parent_turn.permission_profile(),+ client_mcp_extensions,+ ),+ );+ assert!(Arc::ptr_eq(+ &reloaded_child.session.services.exec_policy,+ &parent_thread.session.services.exec_policy,+ ));+ }assert_eq!(reloaded_child.config_snapshot().await.model,"gpt-5.6-luna",@@ -821,8 +943,7 @@ async fn ensure_v2_agent_loaded_reloads_registered_unloaded_agent() {"hello after reload".to_string(),/*trigger_turn*/ false,);- harness- .control+ control.send_inter_agent_communication(spawned_agent.thread_id,communication.clone(),diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rsindex 1b6cec110f..33d9adee7e 100644--- a/codex-rs/core/src/thread_manager.rs+++ b/codex-rs/core/src/thread_manager.rs@@ -328,6 +328,7 @@ pub(crate) struct ResumeThreadWithHistoryOptions {pub(crate) environment_selections: Option<Vec<TurnEnvironmentSelection>>,pub(crate) inherited_environments: Option<TurnEnvironmentSnapshot>,pub(crate) inherited_exec_policy: Option<Arc<crate::exec_policy::ExecPolicyManager>>,+ pub(crate) client_mcp_extensions: Option<ClientMcpExtensions>,}/// Shared, `Arc`-owned state for [`ThreadManager`]. This `Arc` is required to have a single@@ -1012,6 +1013,39 @@ impl ThreadManager {.await}+ /// Reloads a recorded Multi-Agent V2 child through its currently loaded immediate parent.+ ///+ /// The child keeps the existing parent-controlled reload semantics. Callers cannot supply+ /// configuration overrides, and an unavailable or unrecognized owner is an error.+ pub async fn ensure_multi_agent_v2_child_loaded(+ &self,+ child_thread_id: ThreadId,+ ) -> CodexResult<()> {+ let stored_thread = self+ .state+ .read_stored_thread(ReadThreadParams {+ thread_id: child_thread_id,+ include_archived: true,+ include_history: false,+ })+ .await?;+ let Some(parent_thread_id) = stored_thread.parent_thread_id else {+ return Err(CodexErr::InvalidRequest(format!(+ "thread {child_thread_id} is not a recorded multi-agent v2 child"+ )));+ };+ let parent = self.get_thread(parent_thread_id).await.map_err(|_| {+ CodexErr::InvalidRequest(format!(+ "cannot resume multi-agent v2 child {child_thread_id}: parent {parent_thread_id} is not loaded; resume the parent first"+ ))+ })?;+ let config = parent.session.get_config().await.as_ref().clone();+ let agent_control = parent.session.services.agent_control.clone();+ agent_control+ .ensure_v2_agent_loaded(config, child_thread_id, Some(parent))+ .await+ }+#[instrument(level = "trace", skip_all)]pub async fn resume_thread_with_history(&self,@@ -1708,8 +1742,12 @@ impl ThreadManagerState {environment_selections,inherited_environments,inherited_exec_policy,+ client_mcp_extensions,} = options;- let client_mcp_extensions = self.client_mcp_extensions_for_child(parent_thread_id).await;+ let client_mcp_extensions = match client_mcp_extensions {+ Some(client_mcp_extensions) => client_mcp_extensions,+ None => self.client_mcp_extensions_for_child(parent_thread_id).await,+ };let thread_source = initial_history.get_resumed_thread_source();let environments = environment_selections.or_else(|| {inherited_environmentsdiff --git a/codex-rs/core/src/tools/handlers/multi_agents/send_input.rs b/codex-rs/core/src/tools/handlers/multi_agents/send_input.rsindex c5527d19c1..b4ea2e2c5e 100644--- a/codex-rs/core/src/tools/handlers/multi_agents/send_input.rs+++ b/codex-rs/core/src/tools/handlers/multi_agents/send_input.rs@@ -52,7 +52,7 @@ impl Handler {session.services.agent_control- .ensure_v2_agent_loaded(resume_config, receiver_thread_id)+ .ensure_v2_agent_loaded(resume_config, receiver_thread_id, /*parent*/ None).await.map_err(|err| collab_agent_error(receiver_thread_id, err))?;}diff --git a/codex-rs/core/src/tools/handlers/multi_agents_v2/message_tool.rs b/codex-rs/core/src/tools/handlers/multi_agents_v2/message_tool.rsindex e49ce37d89..553dced00d 100644--- a/codex-rs/core/src/tools/handlers/multi_agents_v2/message_tool.rs+++ b/codex-rs/core/src/tools/handlers/multi_agents_v2/message_tool.rs@@ -86,7 +86,7 @@ pub(crate) async fn handle_message_string_tool(session.services.agent_control- .ensure_v2_agent_loaded(resume_config, receiver_thread_id)+ .ensure_v2_agent_loaded(resume_config, receiver_thread_id, /*parent*/ None).await.map_err(|err| collab_agent_error(receiver_thread_id, err))?;let author = turndiff --git a/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs b/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rsindex 5cbaa165d4..394d0a57e9 100644--- a/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs+++ b/codex-rs/core/src/tools/handlers/multi_agents_v2/spawn.rs@@ -150,11 +150,20 @@ async fn handle_spawn_agent(.await?;apply_spawn_agent_runtime_overrides(&mut config, turn.as_ref())?;+ // Remember an applied configured default so cold reload reapplies its restrictions.+ let persisted_role_name = role_name.or_else(|| {+ (!is_full_history_fork+ && config+ .agent_roles+ .get(DEFAULT_ROLE_NAME)+ .is_some_and(|role| role.config_file.is_some()))+ .then_some(DEFAULT_ROLE_NAME)+ });let spawn_source = thread_spawn_source(session.thread_id,&turn.session_source,child_depth,- role_name,+ persisted_role_name,Some(args.task_name.clone()),)?;let new_agent_path = spawn_source.get_agent_path().ok_or_else(|| {diff --git a/codex-rs/core/tests/suite/agent_execution.rs b/codex-rs/core/tests/suite/agent_execution.rsindex dd77cdb547..562334d989 100644--- a/codex-rs/core/tests/suite/agent_execution.rs+++ b/codex-rs/core/tests/suite/agent_execution.rs@@ -1,10 +1,13 @@use anyhow::Result;+use codex_exec_server::CreateDirectoryOptions;use codex_features::Feature;use codex_protocol::models::PermissionProfile;use codex_protocol::models::PermissionProfileSnapshot;use codex_protocol::protocol::EnvironmentConfig;use codex_protocol::protocol::EnvironmentConfigState;use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::ThreadSettingsOverrides;+use codex_protocol::protocol::TurnEnvironmentSelections;use core_test_support::responses::ResponseMock;use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;@@ -13,11 +16,13 @@ use core_test_support::responses::ev_response_created;use core_test_support::responses::mount_sse_once_match;use core_test_support::responses::sse;use core_test_support::responses::start_mock_server;+use core_test_support::submit_thread_settings;use core_test_support::test_codex::test_codex;use core_test_support::wait_for_event;use pretty_assertions::assert_eq;use serde_json::json;use std::time::Duration;+use test_case::test_case;const FIRST_PROMPT: &str = "spawn the first worker";const FIRST_TASK: &str = "first worker task";@@ -198,8 +203,22 @@ async fn v2_nested_spawn_checks_shared_active_execution_capacity() -> Result<()>Ok(())}+#[derive(Clone, Copy, PartialEq, Eq)]+enum ResidencyReload {+ Sender,+ OwnerNarrowsPermissions,+ OwnerPreservesStricterChild,+ OwnerRevokesWorkspaceRoot,+}++#[test_case(ResidencyReload::Sender; "sender preserves stricter child")]+#[test_case(ResidencyReload::OwnerNarrowsPermissions; "owner narrows cached permissions")]+#[test_case(ResidencyReload::OwnerPreservesStricterChild; "owner preserves stricter child")]+#[test_case(ResidencyReload::OwnerRevokesWorkspaceRoot; "owner revokes cached workspace root")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn v2_residency_reload_preserves_inherited_environment_and_tools() -> Result<()> {+async fn v2_residency_reload_preserves_inherited_environment_and_tools(+ reload: ResidencyReload,+) -> Result<()> {const EVICT_PROMPT: &str = "spawn the replacement worker";const FOLLOWUP_PROMPT: &str = "continue the original worker";const FOLLOWUP_TASK: &str = "continue work in the original environment";@@ -254,15 +273,51 @@ async fn v2_residency_reload_preserves_inherited_environment_and_tools() -> Resu});let test = builder.build_with_remote_and_local_env(&server).await?;let mut child_environment = test.executor_environment().selection().clone();- child_environment.config = EnvironmentConfigState::Ready(EnvironmentConfig {- allow_login_shell: test.config.permissions.allow_login_shell,- permission_profile: PermissionProfileSnapshot::legacy(PermissionProfile::read_only()),- shell_environment_policy: Default::default(),- exec_policy: None,- mcp_policy: None,- network_policy: None,- selected_capability_roots: Vec::new(),- });+ let (child_permissions, parent_permissions) = match reload {+ ResidencyReload::Sender => (+ PermissionProfile::read_only(),+ PermissionProfile::workspace_write(),+ ),+ ResidencyReload::OwnerNarrowsPermissions => {+ (PermissionProfile::Disabled, PermissionProfile::read_only())+ }+ ResidencyReload::OwnerPreservesStricterChild => {+ (PermissionProfile::read_only(), PermissionProfile::Disabled)+ }+ ResidencyReload::OwnerRevokesWorkspaceRoot => (+ PermissionProfile::workspace_write(),+ PermissionProfile::workspace_write(),+ ),+ };+ if reload == ResidencyReload::OwnerRevokesWorkspaceRoot {+ child_environment.cwd = test.workspace_path_uri("retained")?;+ child_environment.workspace_roots = vec![+ child_environment.cwd.clone(),+ test.workspace_path_uri("revoked")?,+ ];+ for root in &child_environment.workspace_roots {+ test.fs()+ .create_directory(+ root,+ CreateDirectoryOptions {+ recursive: true,+ follow_symlinks: true,+ },+ /*sandbox*/ None,+ )+ .await?;+ }+ } else {+ child_environment.config = EnvironmentConfigState::Ready(EnvironmentConfig {+ allow_login_shell: test.config.permissions.allow_login_shell,+ permission_profile: PermissionProfileSnapshot::legacy(child_permissions),+ shell_environment_policy: Default::default(),+ exec_policy: None,+ mcp_policy: None,+ network_policy: None,+ selected_capability_roots: Vec::new(),+ });+ }if let Some(exec_server_url) = test.executor_environment().exec_server_url() {test.thread_manager.environment_manager()@@ -274,8 +329,18 @@ async fn v2_residency_reload_preserves_inherited_environment_and_tools() -> Resu}let mut created_threads = test.thread_manager.subscribe_thread_created();- test.submit_turn_with_environments(FIRST_PROMPT, Some(vec![child_environment.clone()]))- .await?;+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ environments: Some(TurnEnvironmentSelections::new(+ test.config.cwd.clone(),+ vec![child_environment.clone()],+ )),+ ..Default::default()+ },+ )+ .await?;+ test.submit_text_turn(FIRST_PROMPT).await?;let first_thread_id = created_threads.recv().await?;let first_thread = test.thread_manager.get_thread(first_thread_id).await?;wait_for_event(first_thread.as_ref(), |event| {@@ -283,14 +348,29 @@ async fn v2_residency_reload_preserves_inherited_environment_and_tools() -> Resu}).await;- let mut sender_environment = child_environment.clone();- let EnvironmentConfigState::Ready(sender_config) = &mut sender_environment.config else {- unreachable!("child environment config should be ready");- };- sender_config.permission_profile =- PermissionProfileSnapshot::legacy(PermissionProfile::workspace_write());- test.submit_turn_with_environments(EVICT_PROMPT, Some(vec![sender_environment]))+ let mut parent_environment = child_environment.clone();+ if reload == ResidencyReload::OwnerRevokesWorkspaceRoot {+ parent_environment.workspace_roots.truncate(1);+ } else {+ let EnvironmentConfigState::Ready(parent_config) = &mut parent_environment.config else {+ unreachable!("child environment config should be ready");+ };+ parent_config.permission_profile = PermissionProfileSnapshot::legacy(parent_permissions);+ }+ if reload == ResidencyReload::Sender {+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ environments: Some(TurnEnvironmentSelections::new(+ test.config.cwd.clone(),+ vec![parent_environment.clone()],+ )),+ ..Default::default()+ },+ ).await?;+ }+ test.submit_text_turn(EVICT_PROMPT).await?;let replacement_thread_id = created_threads.recv().await?;let replacement_thread = test.thread_manager@@ -307,6 +387,62 @@ async fn v2_residency_reload_preserves_inherited_environment_and_tools() -> Resu.is_err());+ if reload != ResidencyReload::Sender {+ submit_thread_settings(+ &test.codex,+ ThreadSettingsOverrides {+ environments: Some(TurnEnvironmentSelections::new(+ test.config.cwd.clone(),+ vec![parent_environment.clone()],+ )),+ ..Default::default()+ },+ )+ .await?;+ assert_eq!(+ test.codex.config_snapshot().await.environments.environments,+ vec![parent_environment]+ );+ let result = test+ .thread_manager+ .ensure_multi_agent_v2_child_loaded(first_thread_id)+ .await;+ let expected_error = match reload {+ ResidencyReload::OwnerRevokesWorkspaceRoot => {+ Some("no longer matches a ready parent environment")+ }+ ResidencyReload::OwnerNarrowsPermissions+ | ResidencyReload::OwnerPreservesStricterChild+ if test.executor_environment().environment().is_remote() =>+ {+ Some("permissions changed on a remote executor")+ }+ ResidencyReload::Sender+ | ResidencyReload::OwnerNarrowsPermissions+ | ResidencyReload::OwnerPreservesStricterChild => None,+ };+ if let Some(expected_error) = expected_error {+ let error = result.expect_err("reload must reject stale owner authority");+ assert!(+ error.to_string().contains(expected_error),+ "unexpected reload error: {error}"+ );+ assert!(+ test.thread_manager+ .get_thread(first_thread_id)+ .await+ .is_err()+ );+ return Ok(());+ }+ result?;+ let EnvironmentConfigState::Ready(child_config) = &mut child_environment.config else {+ unreachable!("successfully reloaded child environment config should be ready");+ };+ child_config.permission_profile =+ PermissionProfileSnapshot::legacy(PermissionProfile::read_only());+ }+test.submit_text_turn(FOLLOWUP_PROMPT).await?;let reloaded_worker = test.thread_manager.get_thread(first_thread_id).await?;wait_for_event(reloaded_worker.as_ref(), |event| {diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex dfa83dc4bf..9ef96b70a6 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -2189,15 +2189,7 @@ fn selected_and_resumed_threads_use_server_capability_for_v1_and_v2_children() -runtime.block_on(async {let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;- let mut app_server =- crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;- let root = app_server- .start_thread(app.chat_widget.config_ref())- .await?;- let root_thread_id = root.session.thread_id;- app.enqueue_primary_thread_session(root.session, root.turns)- .await?;-+ let root_thread_id = ThreadId::new();let rollout_dir = app.config.codex_home@@ -2206,6 +2198,29 @@ fn selected_and_resumed_threads_use_server_capability_for_v1_and_v2_children() -.join("01").join("01");std::fs::create_dir_all(&rollout_dir)?;+ let root_session_meta = SessionMeta {+ session_id: root_thread_id.into(),+ id: root_thread_id,+ timestamp: "2026-01-01T00:00:00Z".to_string(),+ cwd: app.config.cwd.to_path_buf(),+ originator: "codex-tui-test".to_string(),+ cli_version: "0.0.0".to_string(),+ source: RolloutSessionSource::Cli,+ model_provider: Some(app.config.model_provider_id.clone()),+ multi_agent_version: Some(MultiAgentVersion::V2),+ ..SessionMeta::default()+ };+ let root_session_meta_line = serde_json::json!({+ "timestamp": "2026-01-01T00:00:00Z",+ "type": "session_meta",+ "payload": serde_json::to_value(root_session_meta)?,+ });+ std::fs::write(+ rollout_dir.join(format!(+ "rollout-2026-01-01T00-00-00-{root_thread_id}.jsonl"+ )),+ format!("{root_session_meta_line}\n"),+ )?;let mut child_thread_ids = Vec::new();for (index, multi_agent_version) in [MultiAgentVersion::V1, MultiAgentVersion::V2].into_iter()@@ -2214,7 +2229,7 @@ fn selected_and_resumed_threads_use_server_capability_for_v1_and_v2_children() -let child_thread_id = ThreadId::new();let timestamp = format!("2026-01-01T00:00:0{index}Z");let session_meta = SessionMeta {- session_id: child_thread_id.into(),+ session_id: root_thread_id.into(),id: child_thread_id,parent_thread_id: Some(root_thread_id),timestamp: timestamp.clone(),@@ -2241,7 +2256,26 @@ fn selected_and_resumed_threads_use_server_capability_for_v1_and_v2_children() -"payload": serde_json::to_value(session_meta)?,});std::fs::write(rollout_path, format!("{session_meta_line}\n"))?;+ child_thread_ids.push(child_thread_id);+ }+ // Cold-resume the persisted V2 root so its children are registered before selection.+ let mut app_server =+ crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;+ let root = app_server+ .resume_thread(+ app.config.clone(),+ root_thread_id,+ crate::app_server_session::ResumeModelSettings::PreserveExistingThread,+ )+ .await?;+ app.enqueue_primary_thread_session(root.session, root.turns)+ .await?;+ for (child_thread_id, multi_agent_version) in child_thread_ids+ .iter()+ .copied()+ .zip([MultiAgentVersion::V1, MultiAgentVersion::V2])+ {assert!(app.attach_live_thread_for_selection(&mut app_server, child_thread_id).await?@@ -2250,7 +2284,6 @@ fn selected_and_resumed_threads_use_server_capability_for_v1_and_v2_children() -app.agent_navigation.is_parent_owned(child_thread_id),multi_agent_version == MultiAgentVersion::V2);- child_thread_ids.push(child_thread_id);}app.agent_navigation