diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs
index 1d58e7317d..64e17a397d 100644
--- a/codex-rs/app-server/src/codex_message_processor.rs
+++ b/codex-rs/app-server/src/codex_message_processor.rs
@@ -5484,8 +5484,29 @@ impl CodexMessageProcessor {
             let extra_roots = extra_roots_by_cwd
                 .get(&cwd)
                 .map_or(&[][..], std::vec::Vec::as_slice);
+            let config_layer_stack = match load_config_layers_state(
+                &self.codex_home,
+                Some(cwd_abs),
+                &cli_overrides,
+                LoaderOverrides::default(),
+                CloudRequirementsLoader::default(),
+            )
+            .await
+            {
+                Ok(config_layer_stack) => config_layer_stack,
+                Err(err) => {
+                    return SkillLoadOutcome {
+                        errors: vec![crate::skills::model::SkillError {
+                            path: cwd.to_path_buf(),
+                            message: err.to_string(),
+                        }],
+                        ..Default::default()
+                    };
+                }
+            };
+            let effective_skill_roots = skills_manager.effective_skill_roots(&config_layer_stack);
             let outcome = skills_manager
-                .skills_for_cwd_with_extra_user_roots(&cwd, &config, force_reload, extra_roots)
+                .skills_for_cwd_with_extra_user_roots(&cwd, &effective_skill_roots, force_reload, extra_roots, &config_layer_stack)
                 .await;
             let errors = errors_to_info(&outcome.errors);
             let skills = skills_to_info(&outcome.skills, &outcome.disabled_paths);
diff --git a/codex-rs/core-skills/Cargo.toml b/codex-rs/core-skills/Cargo.toml
index 80f6d43daa..c99d42f41a 100644
--- a/codex-rs/core-skills/Cargo.toml
+++ b/codex-rs/core-skills/Cargo.toml
@@ -17,6 +17,7 @@ anyhow = { workspace = true }
 codex-analytics = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 codex-config = { workspace = true }
+codex-core = { path = "../core" }
 codex-instructions = { workspace = true }
 codex-login = { workspace = true }
 codex-otel = { workspace = true }
diff --git a/codex-rs/core-skills/src/skills/manager.rs b/codex-rs/core-skills/src/skills/manager.rs
index 5352f18d01..82c9d52b50 100644
--- a/codex-rs/core-skills/src/skills/manager.rs
+++ b/codex-rs/core-skills/src/skills/manager.rs
@@ -6,6 +6,8 @@ use std::sync::Arc;
 use std::sync::RwLock;
 
 use codex_config::ConfigLayerStack;
+use codex_config::CloudRequirementsLoader;
+use codex_config::LoaderOverrides;
 use codex_protocol::protocol::Product;
 use codex_protocol::protocol::SkillScope;
 use codex_utils_absolute_path::AbsolutePathBuf;
@@ -13,9 +15,7 @@ use toml::Value as TomlValue;
 use tracing::info;
 use tracing::warn;
 
-use crate::config_loader::CloudRequirementsLoader;
-use crate::config_loader::LoaderOverrides;
-use crate::config_loader::load_config_layers_state;
+
 use crate::skills::SkillLoadOutcome;
 use crate::skills::build_implicit_skill_path_indexes;
 use crate::skills::config_rules::SkillConfigRules;
@@ -119,12 +119,13 @@ impl SkillsManager {
         cwd: &Path,
         config: &Config,
         force_reload: bool,
+        config_layer_stack: &ConfigLayerStack,
     ) -> SkillLoadOutcome {
         if !force_reload && let Some(outcome) = self.cached_outcome_for_cwd(cwd) {
             return outcome;
         }
 
-        self.skills_for_cwd_with_extra_user_roots(cwd, config, force_reload, &[])
+        self.skills_for_cwd_with_extra_user_roots(cwd, effective_skill_roots, force_reload, &[], config_layer_stack)
             .await
     }
 
@@ -134,6 +135,7 @@ impl SkillsManager {
         effective_skill_roots: &[PathBuf],
         force_reload: bool,
         extra_user_roots: &[PathBuf],
+        config_layer_stack: &ConfigLayerStack,
     ) -> SkillLoadOutcome {
         if !force_reload && let Some(outcome) = self.cached_outcome_for_cwd(cwd) {
             return outcome;
@@ -154,26 +156,6 @@ impl SkillsManager {
         };
 
         let cli_overrides: Vec<(String, TomlValue)> = Vec::new();
-        let config_layer_stack = match load_config_layers_state(
-            &self.codex_home,
-            Some(cwd_abs),
-            &cli_overrides,
-            LoaderOverrides::default(),
-            CloudRequirementsLoader::default(),
-        )
-        .await
-        {
-            Ok(config_layer_stack) => config_layer_stack,
-            Err(err) => {
-                return SkillLoadOutcome {
-                    errors: vec![crate::skills::model::SkillError {
-                        path: cwd.to_path_buf(),
-                        message: err.to_string(),
-                    }],
-                    ..Default::default()
-                };
-            }
-        };
 
         let mut roots = skill_roots(
             &config_layer_stack,
diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs
index d84d5a49b0..e2a491fe11 100644
--- a/codex-rs/core/src/codex.rs
+++ b/codex-rs/core/src/codex.rs
@@ -4938,8 +4938,30 @@ mod handlers {
         let config = sess.get_config().await;
         let mut skills = Vec::new();
         for cwd in cwds {
+
+            let config_layer_stack = match load_config_layers_state(
+                &self.codex_home,
+                Some(cwd_abs),
+                &cli_overrides,
+                LoaderOverrides::default(),
+                CloudRequirementsLoader::default(),
+            )
+            .await
+            {
+                Ok(config_layer_stack) => config_layer_stack,
+                Err(err) => {
+                    return SkillLoadOutcome {
+                        errors: vec![crate::skills::model::SkillError {
+                            path: cwd.to_path_buf(),
+                            message: err.to_string(),
+                        }],
+                        ..Default::default()
+                    };
+                }
+            };
+            let effective_skill_roots = skills_manager.effective_skill_roots(&config_layer_stack);
             let outcome = skills_manager
-                .skills_for_cwd(&cwd, config.as_ref(), force_reload)
+                .skills_for_cwd(&cwd, &effective_skill_roots, force_reload, &config_layer_stack)
                 .await;
             let errors = super::errors_to_info(&outcome.errors);
             let skills_metadata = super::skills_to_info(&outcome.skills, &outcome.disabled_paths);
diff --git a/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs b/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs
index 8c4f24ed05..32cd9aa89a 100644
--- a/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs
+++ b/codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs
@@ -486,12 +486,28 @@ impl CoreShellActionProvider {
     /// any skills.
     async fn find_skill(&self, program: &AbsolutePathBuf) -> Option<SkillMetadata> {
         let force_reload = false;
-        let skills_outcome = self
-            .session
-            .services
-            .skills_manager
-            .skills_for_cwd(&self.turn.cwd, self.turn.config.as_ref(), force_reload)
-            .await;
+        let config_layer_stack = match load_config_layers_state(
+            &self.codex_home,
+            Some(cwd_abs),
+            &cli_overrides,
+            LoaderOverrides::default(),
+            CloudRequirementsLoader::default(),
+        )
+        .await
+        {
+            Ok(config_layer_stack) => config_layer_stack,
+            Err(err) => {
+                return SkillLoadOutcome {
+                    errors: vec![crate::skills::model::SkillError {
+                        path: cwd.to_path_buf(),
+                        message: err.to_string(),
+                    }],
+                    ..Default::default()
+                };
+            }
+        };
+        let effective_skill_roots = skills_manager.effective_skill_roots(&config_layer_stack);
+        let skills_outcome = self.session.services.skills_manager.skills_for_cwd(&self.turn.cwd, &effective_skill_roots, force_reload, &config_layer_stack).await;
 
         let program_path = program.as_path();
         for skill in skills_outcome.skills {