[codex] Remove legacy ListSkills op (#21282)

## Why

`skills/list` is already exposed through app-server v2 and covered by
the app-server test suite. Keeping the separate core `Op::ListSkills`
path leaves a duplicate legacy protocol surface that no longer needs to
be maintained.

## What Changed

- Removed `Op::ListSkills` and `EventMsg::ListSkillsResponse` from the
core protocol.
- Deleted the corresponding core session handler and stale core
integration tests.
- Removed rollout/MCP ignore branches and protocol v1 docs references
for the deleted event/op.
- Left app-server `skills/list` and its existing coverage intact.

## Validation

- `cargo test -p codex-protocol`
- `cargo test -p codex-core --test all suite::skills`
- `cargo check -p codex-mcp-server -p codex-rollout -p
codex-rollout-trace`
- `just fix -p codex-core`

codex-rs/core/src/session/handlers.rs

@@ -18,14 +18,8 @@ use crate::realtime_context::REALTIME_TURN_TOKEN_BUDGET;
 use crate::realtime_context::truncate_realtime_text_to_token_budget;
 use crate::realtime_conversation::REALTIME_USER_TEXT_PREFIX;
 use crate::realtime_conversation::prefix_realtime_v2_text;
-use crate::session::spawn_review_thread;
-use codex_config::CloudRequirementsLoader;
-use codex_config::LoaderOverrides;
-use codex_config::loader::load_config_layers_state;
-use codex_exec_server::LOCAL_FS;
-use codex_utils_absolute_path::AbsolutePathBuf;
-
 use crate::review_prompts::resolve_review_request;
+use crate::session::spawn_review_thread;
 use crate::tasks::CompactTask;
 use crate::tasks::UserShellCommandMode;
 use crate::tasks::UserShellCommandTask;
@@ -41,7 +35,6 @@ use codex_protocol::protocol::EventMsg;
 use codex_protocol::protocol::GuardianAssessmentEvent;
 use codex_protocol::protocol::GuardianAssessmentStatus;
 use codex_protocol::protocol::InterAgentCommunication;
-use codex_protocol::protocol::ListSkillsResponseEvent;
 use codex_protocol::protocol::McpServerRefreshConfig;
 use codex_protocol::protocol::Op;
 use codex_protocol::protocol::RealtimeConversationListVoicesResponseEvent;
@@ -49,8 +42,6 @@ use codex_protocol::protocol::RealtimeVoicesList;
 use codex_protocol::protocol::ReviewDecision;
 use codex_protocol::protocol::ReviewRequest;
 use codex_protocol::protocol::RolloutItem;
-use codex_protocol::protocol::SkillErrorInfo;
-use codex_protocol::protocol::SkillsListEntry;
 use codex_protocol::protocol::ThreadMemoryMode;
 use codex_protocol::protocol::ThreadRolledBackEvent;
 use codex_protocol::protocol::TurnAbortReason;
@@ -69,7 +60,6 @@ use codex_protocol::user_input::UserInput;
 use codex_rmcp_client::ElicitationAction;
 use codex_rmcp_client::ElicitationResponse;
 use serde_json::Value;
-use std::path::PathBuf;
 use std::sync::Arc;
 use tracing::debug;
 use tracing::info;
@@ -555,98 +545,6 @@ pub async fn list_mcp_tools(sess: &Session, config: &Arc<Config>, sub_id: String
     sess.send_event_raw(event).await;
 }
 
-pub async fn list_skills(sess: &Session, sub_id: String, cwds: Vec<PathBuf>, force_reload: bool) {
-    let default_cwd = {
-        let state = sess.state.lock().await;
-        state.session_configuration.cwd.to_path_buf()
-    };
-    let cwds = if cwds.is_empty() {
-        vec![default_cwd]
-    } else {
-        cwds
-    };
-
-    let skills_manager = &sess.services.skills_manager;
-    let plugins_manager = &sess.services.plugins_manager;
-    let fs = sess
-        .services
-        .environment_manager
-        .default_environment()
-        .map(|environment| environment.get_filesystem());
-    let config = sess.get_config().await;
-    let codex_home = sess.codex_home().await;
-    let mut skills = Vec::new();
-    let empty_cli_overrides: &[(String, toml::Value)] = &[];
-    for cwd in cwds {
-        let cwd_abs = match AbsolutePathBuf::relative_to_current_dir(cwd.as_path()) {
-            Ok(path) => path,
-            Err(err) => {
-                let error_path = cwd.clone();
-                skills.push(SkillsListEntry {
-                    cwd,
-                    skills: Vec::new(),
-                    errors: vec![SkillErrorInfo {
-                        path: error_path,
-                        message: err.to_string(),
-                    }],
-                });
-                continue;
-            }
-        };
-        let config_layer_stack = match load_config_layers_state(
-            LOCAL_FS.as_ref(),
-            &codex_home,
-            Some(cwd_abs.clone()),
-            empty_cli_overrides,
-            LoaderOverrides::default(),
-            CloudRequirementsLoader::default(),
-            &codex_config::NoopThreadConfigLoader,
-        )
-        .await
-        {
-            Ok(config_layer_stack) => config_layer_stack,
-            Err(err) => {
-                let error_path = cwd.clone();
-                skills.push(SkillsListEntry {
-                    cwd,
-                    skills: Vec::new(),
-                    errors: vec![SkillErrorInfo {
-                        path: error_path,
-                        message: err.to_string(),
-                    }],
-                });
-                continue;
-            }
-        };
-        let plugins_input = config.plugins_config_input();
-        let effective_skill_roots = plugins_manager
-            .effective_skill_roots_for_layer_stack(&config_layer_stack, &plugins_input)
-            .await;
-        let skills_input = crate::SkillsLoadInput::new(
-            cwd_abs.clone(),
-            effective_skill_roots,
-            config_layer_stack,
-            config.bundled_skills_enabled(),
-        );
-        let outcome = skills_manager
-            .skills_for_cwd(&skills_input, force_reload, fs.clone())
-            .await;
-        let errors = super::errors_to_info(&outcome.errors);
-        let skills_metadata = super::skills_to_info(&outcome.skills, &outcome.disabled_paths);
-        skills.push(SkillsListEntry {
-            cwd,
-            skills: skills_metadata,
-            errors,
-        });
-    }
-
-    let event = Event {
-        id: sub_id,
-        msg: EventMsg::ListSkillsResponse(ListSkillsResponseEvent { skills }),
-    };
-    sess.send_event_raw(event).await;
-}
-
 pub async fn compact(sess: &Arc<Session>, sub_id: String) {
     let turn_context = sess.new_default_turn_with_sub_id(sub_id).await;
 
@@ -1032,10 +930,6 @@ pub(super) async fn submission_loop(
                     reload_user_config(&sess).await;
                     false
                 }
-                Op::ListSkills { cwds, force_reload } => {
-                    list_skills(&sess, sub.id.clone(), cwds, force_reload).await;
-                    false
-                }
                 Op::Compact => {
                     compact(&sess, sub.id.clone()).await;
                     false

codex-rs/core/src/session/mod.rs

@@ -266,8 +266,9 @@ pub(crate) struct PreviousTurnSettings {
     pub(crate) realtime_active: Option<bool>,
 }
 
-use crate::SkillError;
+#[cfg(test)]
 use crate::SkillLoadOutcome;
+#[cfg(test)]
 use crate::SkillMetadata;
 use crate::SkillsManager;
 use crate::agents_md::AgentsMdManager;
@@ -342,11 +343,6 @@ use codex_protocol::protocol::ReviewDecision;
 use codex_protocol::protocol::SandboxPolicy;
 use codex_protocol::protocol::SessionConfiguredEvent;
 use codex_protocol::protocol::SessionNetworkProxyRuntime;
-use codex_protocol::protocol::SkillDependencies as ProtocolSkillDependencies;
-use codex_protocol::protocol::SkillErrorInfo;
-use codex_protocol::protocol::SkillInterface as ProtocolSkillInterface;
-use codex_protocol::protocol::SkillMetadata as ProtocolSkillMetadata;
-use codex_protocol::protocol::SkillToolDependency as ProtocolSkillToolDependency;
 use codex_protocol::protocol::StreamErrorEvent;
 use codex_protocol::protocol::Submission;
 use codex_protocol::protocol::ThreadMemoryMode;
@@ -984,6 +980,7 @@ impl Session {
         }
     }
 
+    #[cfg(test)]
     pub(crate) async fn codex_home(&self) -> AbsolutePathBuf {
         let state = self.state.lock().await;
         state.session_configuration.codex_home().clone()
@@ -3293,60 +3290,6 @@ pub(crate) fn emit_subagent_session_started(
     });
 }
 
-fn skills_to_info(
-    skills: &[SkillMetadata],
-    disabled_paths: &HashSet<AbsolutePathBuf>,
-) -> Vec<ProtocolSkillMetadata> {
-    skills
-        .iter()
-        .map(|skill| ProtocolSkillMetadata {
-            name: skill.name.clone(),
-            description: skill.description.clone(),
-            short_description: skill.short_description.clone(),
-            interface: skill
-                .interface
-                .clone()
-                .map(|interface| ProtocolSkillInterface {
-                    display_name: interface.display_name,
-                    short_description: interface.short_description,
-                    icon_small: interface.icon_small,
-                    icon_large: interface.icon_large,
-                    brand_color: interface.brand_color,
-                    default_prompt: interface.default_prompt,
-                }),
-            dependencies: skill.dependencies.clone().map(|dependencies| {
-                ProtocolSkillDependencies {
-                    tools: dependencies
-                        .tools
-                        .into_iter()
-                        .map(|tool| ProtocolSkillToolDependency {
-                            r#type: tool.r#type,
-                            value: tool.value,
-                            description: tool.description,
-                            transport: tool.transport,
-                            command: tool.command,
-                            url: tool.url,
-                        })
-                        .collect(),
-                }
-            }),
-            path: skill.path_to_skills_md.clone(),
-            scope: skill.scope,
-            enabled: !disabled_paths.contains(&skill.path_to_skills_md),
-        })
-        .collect()
-}
-
-fn errors_to_info(errors: &[SkillError]) -> Vec<SkillErrorInfo> {
-    errors
-        .iter()
-        .map(|err| SkillErrorInfo {
-            path: err.path.to_path_buf(),
-            message: err.message.clone(),
-        })
-        .collect()
-}
-
 use codex_memories_read::build_memory_tool_developer_instructions;
 
 /// Builds the hook engine for one config snapshot, including any enabled plugin hooks.

codex-rs/core/src/session/turn.rs

@@ -1506,7 +1506,6 @@ pub(super) fn realtime_text_for_event(msg: &EventMsg) -> Option<String> {
         | EventMsg::TurnDiff(_)
         | EventMsg::GetHistoryEntryResponse(_)
         | EventMsg::McpListToolsResponse(_)
-        | EventMsg::ListSkillsResponse(_)
         | EventMsg::RealtimeConversationListVoicesResponse(_)
         | EventMsg::SkillsUpdateAvailable
         | EventMsg::PlanUpdate(_)

codex-rs/core/src/session/turn_context.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::SkillLoadOutcome;
 use crate::config::GhostSnapshotConfig;
 use crate::environment_selection::ResolvedTurnEnvironments;
 use codex_model_provider::SharedModelProvider;