From f802f0a3911655ac0e2876fceedf8ad833431df3 Mon Sep 17 00:00:00 2001
From: jif-oai <jif@openai.com>
Date: Fri, 24 Apr 2026 17:57:48 +0200
Subject: [PATCH] chore: drop MCP Plugins and App from Morpheus (#19380)

Quick fix of https://github.com/openai/codex/issues/18333
---
 codex-rs/core/src/memories/phase2.rs |  8 +++++
 codex-rs/core/src/memories/tests.rs  | 53 +++++++++++++++++++++++++++-
 2 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/codex-rs/core/src/memories/phase2.rs b/codex-rs/core/src/memories/phase2.rs
index ffabb06ed..84404f48f 100644
--- a/codex-rs/core/src/memories/phase2.rs
+++ b/codex-rs/core/src/memories/phase2.rs
@@ -26,6 +26,7 @@ use codex_protocol::protocol::TokenUsage;
 use codex_protocol::user_input::UserInput;
 use codex_state::Stage1Output;
 use codex_state::StateRuntime;
+use std::collections::HashMap;
 use std::collections::HashSet;
 use std::sync::Arc;
 use std::time::Duration;
@@ -303,12 +304,19 @@ mod agent {
         agent_config.ephemeral = true;
         agent_config.memories.generate_memories = false;
         agent_config.memories.use_memories = false;
+        agent_config.include_apps_instructions = false;
+        agent_config.mcp_servers = Constrained::allow_only(HashMap::new());
         // Approval policy
         agent_config.permissions.approval_policy = Constrained::allow_only(AskForApproval::Never);
         // Consolidation runs as an internal sub-agent and must not recursively delegate.
         let _ = agent_config.features.disable(Feature::SpawnCsv);
         let _ = agent_config.features.disable(Feature::Collab);
         let _ = agent_config.features.disable(Feature::MemoryTool);
+        let _ = agent_config.features.disable(Feature::Apps);
+        let _ = agent_config.features.disable(Feature::Plugins);
+        let _ = agent_config
+            .features
+            .disable(Feature::SkillMcpDependencyInstall);
 
         // Sandbox policy
         let writable_roots = vec![root];
diff --git a/codex-rs/core/src/memories/tests.rs b/codex-rs/core/src/memories/tests.rs
index 1b5614d31..d4c659bfc 100644
--- a/codex-rs/core/src/memories/tests.rs
+++ b/codex-rs/core/src/memories/tests.rs
@@ -427,6 +427,7 @@ mod phase2 {
     use chrono::Duration as ChronoDuration;
     use chrono::Utc;
     use codex_config::Constrained;
+    use codex_config::types::McpServerConfig;
     use codex_features::Feature;
     use codex_login::CodexAuth;
     use codex_protocol::AgentPath;
@@ -440,6 +441,7 @@ mod phase2 {
     use codex_state::Phase2JobClaimOutcome;
     use codex_state::Stage1Output;
     use codex_state::ThreadMetadataBuilder;
+    use std::collections::HashMap;
     use std::path::PathBuf;
     use std::sync::Arc;
     use tempfile::TempDir;
@@ -470,6 +472,10 @@ mod phase2 {
 
     impl DispatchHarness {
         async fn new() -> Self {
+            Self::new_with_config(|_| {}).await
+        }
+
+        async fn new_with_config(configure: impl FnOnce(&mut Config)) -> Self {
             let codex_home = tempfile::tempdir().expect("create temp codex home");
             let mut config = test_config().await;
             config.codex_home =
@@ -478,6 +484,7 @@ mod phase2 {
             config.cwd = config.codex_home.clone();
             config.permissions.file_system_sandbox_policy = FileSystemSandboxPolicy::unrestricted();
             config.permissions.network_sandbox_policy = NetworkSandboxPolicy::Enabled;
+            configure(&mut config);
             let config = Arc::new(config);
 
             let state_db = codex_state::StateRuntime::init(
@@ -642,7 +649,24 @@ mod phase2 {
 
     #[tokio::test]
     async fn dispatch_reclaims_stale_global_lock_and_starts_consolidation() {
-        let harness = DispatchHarness::new().await;
+        let harness = DispatchHarness::new_with_config(|config| {
+            let server: McpServerConfig =
+                toml::from_str("command = \"docs-server\"").expect("deserialize MCP server");
+            config
+                .mcp_servers
+                .set(HashMap::from([("docs".to_string(), server)]))
+                .expect("parent MCP servers are configurable");
+            config
+                .features
+                .enable(Feature::Apps)
+                .expect("apps feature is configurable");
+            config
+                .features
+                .enable(Feature::Plugins)
+                .expect("plugins feature is configurable");
+            config.include_apps_instructions = true;
+        })
+        .await;
         harness.seed_stage1_output(Utc::now().timestamp()).await;
 
         let stale_claim = harness
@@ -751,6 +775,33 @@ mod phase2 {
             !turn_context.features.enabled(Feature::MemoryTool),
             "consolidation subagent should have the memories feature disabled"
         );
+        assert!(
+            turn_context.config.mcp_servers.get().is_empty(),
+            "consolidation subagent should not inherit configured MCP servers"
+        );
+        assert!(
+            !subagent
+                .codex
+                .session
+                .services
+                .mcp_connection_manager
+                .read()
+                .await
+                .has_servers(),
+            "consolidation subagent should not initialize MCP servers"
+        );
+        assert!(
+            !turn_context.features.enabled(Feature::Apps),
+            "consolidation subagent should not expose app-backed MCP"
+        );
+        assert!(
+            !turn_context.features.enabled(Feature::Plugins),
+            "consolidation subagent should not expose plugin-backed MCP"
+        );
+        assert!(
+            !turn_context.config.include_apps_instructions,
+            "consolidation subagent should not include apps instructions"
+        );
         assert!(
             !turn_context.config.memories.generate_memories,
             "consolidation subagent should not generate memories"