use std::time::Duration;use anyhow::Result;use app_test_support::TestAppServer;use app_test_support::to_response;use codex_app_server_protocol::CapabilityRootLocation;use codex_app_server_protocol::JSONRPCResponse;use codex_app_server_protocol::RequestId;use codex_app_server_protocol::SelectedCapabilityRoot;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;use codex_app_server_protocol::TurnStartParams;use codex_app_server_protocol::UserInput;use core_test_support::responses;use tempfile::TempDir;use tokio::time::timeout;const READ_TIMEOUT: Duration = Duration::from_secs(10);const SKILL_NAME: &str = "demo-plugin:deploy";const SKILL_MARKER: &str = "EXECUTOR_SKILL_BODY_MARKER";const LOCAL_SKILL_MARKER: &str = "LOCAL_SKILL_BODY_MARKER";#[tokio::test]async fn selected_executor_root_exposes_plugin_skill() -> Result<()> {    let server = responses::start_mock_server().await;    let response_mock = responses::mount_sse_once(        &server,        responses::sse(vec![            responses::ev_response_created("resp-selected"),            responses::ev_assistant_message("msg-selected", "Done"),            responses::ev_completed("resp-selected"),        ]),    )    .await;    let codex_home = TempDir::new()?;    std::fs::write(        codex_home.path().join("config.toml"),        format!(            r#"model = "mock-model"approval_policy = "never"sandbox_mode = "read-only"model_provider = "mock_provider"[skills]include_instructions = true[model_providers.mock_provider]name = "Mock provider for test"base_url = "{}/v1"wire_api = "responses"request_max_retries = 0stream_max_retries = 0"#,            server.uri()        ),    )?;    let local_skill_dir = codex_home.path().join("skills/local-deploy");    std::fs::create_dir_all(&local_skill_dir)?;    std::fs::write(        local_skill_dir.join("SKILL.md"),        format!(            "---\nname: {SKILL_NAME}\ndescription: Colliding local skill.\n---\n\n# Local deploy\n\n{LOCAL_SKILL_MARKER}\n"        ),    )?;    let plugin_dir = TempDir::new()?;    let manifest_dir = plugin_dir.path().join(".codex-plugin");    let skill_dir = plugin_dir.path().join("skills/deploy");    std::fs::create_dir_all(&manifest_dir)?;    std::fs::create_dir_all(&skill_dir)?;    std::fs::write(        manifest_dir.join("plugin.json"),        r#"{"name":"demo-plugin"}"#,    )?;    std::fs::write(        skill_dir.join("SKILL.md"),        format!(            "---\nname: deploy\ndescription: Deploy through the executor.\n---\n\n# Deploy\n\n{SKILL_MARKER}\n"        ),    )?;    let mut app_server = TestAppServer::new(codex_home.path()).await?;    timeout(READ_TIMEOUT, app_server.initialize()).await??;    let request_id = app_server        .send_thread_start_request(ThreadStartParams {            model: Some("mock-model".to_string()),            selected_capability_roots: Some(vec![SelectedCapabilityRoot {                id: "demo-plugin@1".to_string(),                location: CapabilityRootLocation::Environment {                    environment_id: "local".to_string(),                    path: plugin_dir.path().to_string_lossy().into_owned(),                },            }]),            ..Default::default()        })        .await?;    let response: JSONRPCResponse = timeout(        READ_TIMEOUT,        app_server.read_stream_until_response_message(RequestId::Integer(request_id)),    )    .await??;    let ThreadStartResponse { thread, .. } = to_response(response)?;    let request_id = app_server        .send_turn_start_request(TurnStartParams {            thread_id: thread.id,            input: vec![UserInput::Text {                text: format!("Use ${SKILL_NAME}"),                text_elements: Vec::new(),            }],            ..Default::default()        })        .await?;    timeout(        READ_TIMEOUT,        app_server.read_stream_until_response_message(RequestId::Integer(request_id)),    )    .await??;    timeout(        READ_TIMEOUT,        app_server.read_stream_until_notification_message("turn/completed"),    )    .await??;    let request = response_mock.single_request();    assert!(        request            .message_input_texts("developer")            .iter()            .any(|text| text.contains(SKILL_NAME))    );    let skill_fragments = request        .message_input_texts("user")        .into_iter()        .filter(|text| text.starts_with("<skill>"))        .collect::<Vec<_>>();    assert_eq!(1, skill_fragments.len());    let skill_fragment = skill_fragments        .first()        .expect("executor skill instructions should be model-visible");    assert!(skill_fragment.contains(&format!("<name>{SKILL_NAME}</name>")));    assert!(skill_fragment.contains(SKILL_MARKER));    assert!(!skill_fragment.contains(LOCAL_SKILL_MARKER));    Ok(())}