Lightweight coding agent that runs in your terminal
Rust
Keep multi-workspace skill listings consistent (#37812)
Charlie Marsh1c042dd4d823
diff --git a/codex-rs/app-server/src/request_processors/catalog_processor.rs b/codex-rs/app-server/src/request_processors/catalog_processor.rsindex 38fd521e44..14a60482a7 100644--- a/codex-rs/app-server/src/request_processors/catalog_processor.rs+++ b/codex-rs/app-server/src/request_processors/catalog_processor.rs@@ -514,17 +514,30 @@ impl CatalogRequestProcessor {plugins_manager.clear_cache();skills_service.clear_cache();}+ // Plugin configuration is user-scoped; workspace skill rules are applied below.+ let (effective_skill_roots, plugin_skill_snapshots) = if workspace_codex_plugins_enabled {+ let plugins_input = config.plugins_config_input();+ let plugins = plugins_manager.plugins_for_config(&plugins_input).await;+ (+ plugins.effective_plugin_skill_roots(),+ plugins_manager.plugin_skill_snapshots_for_config(&plugins_input),+ )+ } else {+ (Vec::new(), None)+ };let fs = self.thread_manager.environment_manager().default_environment().map(|environment| environment.get_filesystem());+ let skills_request = skills_service.for_request();let mut data = futures::stream::iter(cwds.into_iter().enumerate()).map(|(index, cwd)| {let config = &config;let fs = fs.clone();- let plugins_manager = &plugins_manager;- let skills_service = &skills_service;+ let skills_request = &skills_request;+ let effective_skill_roots = effective_skill_roots.clone();+ let plugin_skill_snapshots = plugin_skill_snapshots.clone();async move {let (cwd_abs, config_layer_stack) = match self.resolve_cwd_config(&cwd).await {Ok(resolved) => resolved,@@ -543,31 +556,6 @@ impl CatalogRequestProcessor {);}};- let (effective_skill_roots, plugin_skill_snapshots) =- if workspace_codex_plugins_enabled {- let plugins_input = config.plugins_config_input();- if config_layer_stack == plugins_input.config_layer_stack {- let plugins =- plugins_manager.plugins_for_config(&plugins_input).await;- (- plugins.effective_plugin_skill_roots(),- plugins_manager- .plugin_skill_snapshots_for_config(&plugins_input),- )- } else {- (- plugins_manager- .effective_skill_roots_for_layer_stack(- &config_layer_stack,- &plugins_input,- )- .await,- None,- )- }- } else {- (Vec::new(), None)- };let skills_input = codex_core::skills::HostSkillsLoadInput::new(cwd_abs.clone(),effective_skill_roots,@@ -575,7 +563,7 @@ impl CatalogRequestProcessor {config.bundled_skills_enabled(),).with_plugin_skill_snapshots(plugin_skill_snapshots);- let snapshot = skills_service+ let snapshot = skills_request.snapshot_for_cwd(&skills_input, force_reload, fs).await;let outcome = snapshot.outcome();diff --git a/codex-rs/app-server/tests/suite/v2/skills_list.rs b/codex-rs/app-server/tests/suite/v2/skills_list.rsindex 16079ddfcf..2685182748 100644--- a/codex-rs/app-server/tests/suite/v2/skills_list.rs+++ b/codex-rs/app-server/tests/suite/v2/skills_list.rs@@ -24,9 +24,14 @@ use codex_app_server_protocol::SkillsListResponse;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;use codex_config::types::AuthCredentialsStoreMode;+use codex_core::config::set_project_trust_level;use codex_exec_server::CODEX_EXEC_SERVER_URL_ENV_VAR;+use codex_exec_server::CreateDirectoryOptions;+use codex_protocol::config_types::TrustLevel;use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_path_uri::PathUri;use core_test_support::skip_if_remote;+use core_test_support::skip_if_wine_exec;use pretty_assertions::assert_eq;use tempfile::TempDir;use tokio::time::timeout;@@ -777,37 +782,194 @@ async fn skills_list_accepts_relative_cwds() -> Result<()> {#[tokio::test]async fn skills_list_preserves_requested_cwd_order() -> Result<()> {+ skip_if_wine_exec!(+ Ok(()),+ "skills/list currently requires host-native cwd paths for workspace config"+ );let codex_home = TempDir::new()?;let first_cwd = TempDir::new()?;let second_cwd = TempDir::new()?;+ write_skill(&codex_home, "shared-skill")?;+ write_cached_local_curated_plugin_with_skill(codex_home.path())?;+ std::fs::write(+ codex_home.path().join("config.toml"),+ r#"[features]+plugins = true++[plugins."google-calendar@openai-curated"]+enabled = true+"#,+ )?;++ for (cwd, plugin_enabled) in [(first_cwd.path(), true), (second_cwd.path(), false)] {+ std::fs::create_dir_all(cwd.join(".git"))?;+ std::fs::create_dir_all(cwd.join(".codex"))?;+ std::fs::write(+ cwd.join(".codex/config.toml"),+ format!("[plugins.\"google-calendar@openai-curated\"]\nenabled = {plugin_enabled}\n"),+ )?;+ set_project_trust_level(codex_home.path(), cwd, TrustLevel::Trusted)?;+ }let mut mcp = TestAppServer::builder().with_codex_home(codex_home.path())- .without_auto_env().build_initialized_with_timeout(DEFAULT_TIMEOUT).await?;- let request_id = mcp- .send_skills_list_request(SkillsListParams {- cwds: vec![- first_cwd.path().to_path_buf(),- second_cwd.path().to_path_buf(),- ],- force_reload: true,- })- .await?;+ let file_system = mcp.auto_env()?.environment().get_filesystem();+ for (cwd, name) in [+ (first_cwd.path(), "first-project-skill"),+ (second_cwd.path(), "second-project-skill"),+ ] {+ let cwd = AbsolutePathBuf::try_from(cwd)?;+ let git_dir = PathUri::from_abs_path(&cwd.join(".git"));+ let skill_dir = PathUri::from_abs_path(&cwd.join(".agents/skills").join(name));+ for directory in [&git_dir, &skill_dir] {+ file_system+ .create_directory(+ directory,+ CreateDirectoryOptions { recursive: true },+ /*sandbox*/ None,+ )+ .await?;+ }+ file_system+ .write_file(+ &skill_dir.join("SKILL.md")?,+ format!("---\nname: {name}\ndescription: {name}\n---\n").into_bytes(),+ /*sandbox*/ None,+ )+ .await?;+ }- let SkillsListResponse { data } =- timeout(DEFAULT_TIMEOUT, mcp.read_response(request_id)).await??;- assert_eq!(- data.iter()- .map(|entry| entry.cwd.clone())- .collect::<Vec<_>>(),- vec![- first_cwd.path().to_path_buf(),- second_cwd.path().to_path_buf(),- ]+ for (request_index, force_reload) in [false, false, true].into_iter().enumerate() {+ if request_index == 1 {+ write_skill(&codex_home, "new-skill")?;+ }++ let request_id = mcp+ .send_skills_list_request(SkillsListParams {+ cwds: vec![+ first_cwd.path().to_path_buf(),+ second_cwd.path().to_path_buf(),+ ],+ force_reload,+ })+ .await?;+ let SkillsListResponse { data } =+ timeout(DEFAULT_TIMEOUT, mcp.read_response(request_id)).await??;+ assert_eq!(data.len(), 2);+ assert_eq!(data[0].cwd, first_cwd.path());+ assert_eq!(data[1].cwd, second_cwd.path());+ for (entry, project_skill) in data+ .iter()+ .zip(["first-project-skill", "second-project-skill"])+ {+ assert_eq!(entry.errors, Vec::new());+ assert!(+ entry+ .skills+ .iter()+ .any(|skill| skill.name == "shared-skill")+ );+ assert_eq!(+ entry+ .skills+ .iter()+ .filter(|skill| {+ skill.name.ends_with("-project-skill")+ || skill.name.starts_with("google-calendar:")+ })+ .map(|skill| skill.name.as_str())+ .collect::<Vec<_>>(),+ vec![project_skill, "google-calendar:meeting-prep"]+ );+ assert_eq!(+ entry.skills.iter().any(|skill| skill.name == "new-skill"),+ force_reload+ );+ }+ }++ Ok(())+}++#[tokio::test]+async fn skills_list_force_reload_refreshes_cached_plugin_roots() -> Result<()> {+ skip_if_wine_exec!(+ Ok(()),+ "skills/list currently requires host-native cwd paths for workspace config");+ let codex_home = TempDir::new()?;+ let first_cwd = TempDir::new()?;+ let second_cwd = TempDir::new()?;+ write_cached_local_curated_plugin_with_skill(codex_home.path())?;+ std::fs::write(+ codex_home.path().join("config.toml"),+ r#"[features]+plugins = true++[plugins."google-calendar@openai-curated"]+enabled = true+"#,+ )?;++ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build_initialized_with_timeout(DEFAULT_TIMEOUT)+ .await?;++ let file_system = mcp.auto_env()?.environment().get_filesystem();+ for cwd in [first_cwd.path(), second_cwd.path()] {+ let cwd = PathUri::from_abs_path(&AbsolutePathBuf::try_from(cwd)?);+ file_system+ .create_directory(+ &cwd.join(".git")?,+ CreateDirectoryOptions { recursive: true },+ /*sandbox*/ None,+ )+ .await?;+ }++ for (cwd, force_reload, expected_skill) in [+ (first_cwd.path(), false, "google-calendar:meeting-prep"),+ (first_cwd.path(), true, "google-calendar:refreshed-skill"),+ (second_cwd.path(), false, "google-calendar:refreshed-skill"),+ ] {+ if force_reload {+ let plugin_root = codex_home+ .path()+ .join("plugins/cache/openai-curated/google-calendar/local");+ std::fs::write(+ plugin_root.join(".codex-plugin/plugin.json"),+ r#"{"name":"google-calendar","skills":"./replacement-skills"}"#,+ )?;+ let skill_dir = plugin_root.join("replacement-skills/refreshed-skill");+ std::fs::create_dir_all(&skill_dir)?;+ std::fs::write(+ skill_dir.join("SKILL.md"),+ "---\nname: refreshed-skill\ndescription: refreshed skill\n---\n",+ )?;+ }++ let request_id = mcp+ .send_skills_list_request(SkillsListParams {+ cwds: vec![cwd.to_path_buf()],+ force_reload,+ })+ .await?;+ let SkillsListResponse { data } =+ timeout(DEFAULT_TIMEOUT, mcp.read_response(request_id)).await??;+ assert_eq!(+ data[0]+ .skills+ .iter()+ .filter(|skill| skill.name.starts_with("google-calendar:"))+ .map(|skill| skill.name.as_str())+ .collect::<Vec<_>>(),+ vec![expected_skill]+ );+ }Ok(())}diff --git a/codex-rs/core-plugins/src/manager.rs b/codex-rs/core-plugins/src/manager.rsindex 48cb599929..8ad903dc86 100644--- a/codex-rs/core-plugins/src/manager.rs+++ b/codex-rs/core-plugins/src/manager.rs@@ -787,28 +787,6 @@ impl PluginsManager {}}- /// Load plugins for a config layer stack without touching the plugins cache.- pub async fn plugins_for_layer_stack(- &self,- config_layer_stack: &ConfigLayerStack,- config: &PluginsConfigInput,- ) -> PluginLoadOutcome {- if !config.plugins_enabled {- return PluginLoadOutcome::default();- }- let plugins = load_plugins_from_layer_stack(- config_layer_stack,- self.remote_installed_plugins_snapshot(),- &self.store,- /*plugin_skill_snapshots*/ None,- self.restriction_product,- self.remote_global_catalog_active(config),- self.skill_root_loader.as_ref(),- )- .await;- self.resolve_loaded_plugins_for_auth(plugins, &config.model_provider_id)- }-/// Resolve plugin hooks for a config layer stack without loading other plugin capabilities.pub async fn plugin_hooks_for_layer_stack(&self,@@ -830,17 +808,6 @@ impl PluginsManager {.await}- /// Resolve plugin skill roots for a config layer stack without touching the plugins cache.- pub async fn effective_skill_roots_for_layer_stack(- &self,- config_layer_stack: &ConfigLayerStack,- config: &PluginsConfigInput,- ) -> Vec<PluginSkillRoot> {- self.plugins_for_layer_stack(config_layer_stack, config)- .await- .effective_plugin_skill_roots()- }-fn cached_loaded_plugins(&self, key: &PluginLoadCacheKey) -> Option<Vec<LoadedPlugin>> {self.loaded_plugins_cache.read()diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 877ba93dce..581529461e 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -5183,6 +5183,7 @@ async fn new_default_turn_uses_config_aware_skills_for_role_overrides() {let parent_snapshot = session.services.skills_service+ .for_request().snapshot_for_cwd(&crate::skills_load_input_from_config(&parent_config, Vec::new()),/*force_reload*/ true,diff --git a/codex-rs/ext/skills/src/host_service.rs b/codex-rs/ext/skills/src/host_service.rsindex 199c6a0184..3c08db87da 100644--- a/codex-rs/ext/skills/src/host_service.rs+++ b/codex-rs/ext/skills/src/host_service.rs@@ -33,8 +33,10 @@ use crate::HostSkillsSnapshot;use crate::SkillLoadOutcome;use crate::host_roots::resolve_skill_roots;use crate::loader::HostSkillRoot;+use crate::loader::HostSkillRootSnapshot;use crate::loader::MAX_CONCURRENT_ROOT_SCANS;use crate::loader::load_and_merge_host_skill_roots;+use crate::loader::load_and_merge_host_skill_roots_with_request_snapshots;#[derive(Debug, Clone)]pub struct HostSkillsLoadInput {@@ -84,6 +86,33 @@ pub struct HostSkillsService {root_scan_slots: Arc<Semaphore>,}+pub(crate) type RequestSkillRootSnapshots =+ RwLock<HashMap<ConfigSkillRootCacheKey, Arc<OnceCell<HostSkillRootSnapshot>>>>;++/// Shares host-root scans between workspaces for the lifetime of one request.+pub struct HostSkillsRequest<'a> {+ service: &'a HostSkillsService,+ root_snapshots: RequestSkillRootSnapshots,+}++impl HostSkillsRequest<'_> {+ pub async fn snapshot_for_cwd(+ &self,+ input: &HostSkillsLoadInput,+ force_reload: bool,+ fs: Option<Arc<dyn ExecutorFileSystem>>,+ ) -> HostSkillsSnapshot {+ self.service+ .snapshot_for_cwd_with_root_snapshots(+ input,+ force_reload,+ fs,+ Some(&self.root_snapshots),+ )+ .await+ }+}+impl HostSkillsService {pub fn new(codex_home: AbsolutePathBuf, bundled_skills_enabled: bool) -> Self {Self::new_with_restriction_product(codex_home, bundled_skills_enabled, Some(Product::Codex))@@ -110,6 +139,14 @@ impl HostSkillsService {service}+ /// Creates a request-local view without changing persistent plugin snapshots.+ pub fn for_request(&self) -> HostSkillsRequest<'_> {+ HostSkillsRequest {+ service: self,+ root_snapshots: RwLock::new(HashMap::new()),+ }+ }+pub fn set_extra_roots(&self, extra_roots: Vec<AbsolutePathBuf>) {{let mut roots = self@@ -155,6 +192,7 @@ impl HostSkillsService {&skill_config_rules,cache_key,/*force_reload*/ false,+ /*request_root_snapshots*/ None,).await}@@ -181,11 +219,12 @@ impl HostSkillsService {roots}- pub async fn snapshot_for_cwd(+ async fn snapshot_for_cwd_with_root_snapshots(&self,input: &HostSkillsLoadInput,force_reload: bool,fs: Option<Arc<dyn ExecutorFileSystem>>,+ request_root_snapshots: Option<&RequestSkillRootSnapshots>,) -> HostSkillsSnapshot {let bundled_skills_enabled = bundled_skills_enabled_from_stack(&input.config_layer_stack);if bundled_skills_enabled {@@ -224,11 +263,12 @@ impl HostSkillsService {&skill_config_rules,cache_key,force_reload,+ request_root_snapshots,).await} else {HostSkillsSnapshot::new(Arc::new(- self.build_skill_outcome(input, roots, &skill_config_rules)+ self.build_skill_outcome(input, roots, &skill_config_rules, request_root_snapshots).await,))};@@ -249,6 +289,7 @@ impl HostSkillsService {skill_config_rules: &SkillConfigRules,cache_key: ConfigSkillsCacheKey,force_reload: bool,+ request_root_snapshots: Option<&RequestSkillRootSnapshots>,) -> HostSkillsSnapshot {let snapshot_cell = {let mut cache = self@@ -271,8 +312,13 @@ impl HostSkillsService {snapshot_cell.get_or_init(|| async {HostSkillsSnapshot::new(Arc::new(- self.build_skill_outcome(input, roots, skill_config_rules)- .await,+ self.build_skill_outcome(+ input,+ roots,+ skill_config_rules,+ request_root_snapshots,+ )+ .await,))}).await@@ -285,12 +331,14 @@ impl HostSkillsService {input: &HostSkillsLoadInput,roots: Vec<HostSkillRoot>,skill_config_rules: &SkillConfigRules,+ request_root_snapshots: Option<&RequestSkillRootSnapshots>,) -> SkillLoadOutcome {- let outcome = load_and_merge_host_skill_roots(+ let outcome = load_and_merge_host_skill_roots_with_request_snapshots(roots,&self.root_scan_slots,self.restriction_product,input.plugin_skill_snapshots.as_ref(),+ request_root_snapshots,).await;let disabled_paths = skill_config_rules.resolve_disabled_paths(@@ -397,7 +445,7 @@ struct ConfigSkillsCacheKey {}#[derive(Debug, Clone, PartialEq, Eq, Hash)]-struct ConfigSkillRootCacheKey {+pub(crate) struct ConfigSkillRootCacheKey {path: AbsolutePathBuf,scope_rank: u8,plugin_identity: Option<PluginIdentity>,@@ -450,24 +498,7 @@ fn config_skills_cache_key(plugin_skill_snapshots: Option<&SkillRootSnapshots<PluginSkillRoot>>,) -> ConfigSkillsCacheKey {ConfigSkillsCacheKey {- roots: roots- .iter()- .map(|root| {- let scope_rank = match root.scope {- SkillScope::Repo => 0,- SkillScope::User => 1,- SkillScope::System => 2,- SkillScope::Admin => 3,- };- ConfigSkillRootCacheKey {- path: root.path.clone(),- scope_rank,- plugin_identity: root.plugin_identity().cloned(),- plugin_namespace: root.plugin_namespace().map(str::to_string),- file_system: FileSystemIdentity(Arc::downgrade(&root.file_system)),- }- })- .collect(),+ roots: roots.iter().map(config_skill_root_cache_key).collect(),skill_config_rules: skill_config_rules.clone(),plugin_skill_snapshots: plugin_skill_snapshots.filter(|_| roots.iter().any(|root| root.plugin_identity().is_some()))@@ -475,6 +506,22 @@ fn config_skills_cache_key(}}+pub(crate) fn config_skill_root_cache_key(root: &HostSkillRoot) -> ConfigSkillRootCacheKey {+ let scope_rank = match root.scope {+ SkillScope::Repo => 0,+ SkillScope::User => 1,+ SkillScope::System => 2,+ SkillScope::Admin => 3,+ };+ ConfigSkillRootCacheKey {+ path: root.path.clone(),+ scope_rank,+ plugin_identity: root.plugin_identity().cloned(),+ plugin_namespace: root.plugin_namespace().map(str::to_string),+ file_system: FileSystemIdentity(Arc::downgrade(&root.file_system)),+ }+}+#[cfg(test)]#[path = "host_service_tests.rs"]mod tests;diff --git a/codex-rs/ext/skills/src/host_service_tests.rs b/codex-rs/ext/skills/src/host_service_tests.rsindex e650b27b34..d5217b3be2 100644--- a/codex-rs/ext/skills/src/host_service_tests.rs+++ b/codex-rs/ext/skills/src/host_service_tests.rs@@ -305,6 +305,76 @@ async fn snapshot_for_config_preserves_host_precedence_for_symlinked_plugin_root);}+#[tokio::test]+async fn skills_list_snapshots_share_host_roots_only_within_one_request() {+ let codex_home = tempfile::tempdir().expect("tempdir");+ let first_cwd = tempfile::tempdir().expect("tempdir");+ let second_cwd = tempfile::tempdir().expect("tempdir");+ let config_layer_stack = config_stack(&codex_home, "");+ let disabled_config_layer_stack = config_stack(+ &codex_home,+ &name_toggle_config("first-skill", /*enabled*/ false),+ );+ let skills_service = HostSkillsService::new(+ codex_home.path().abs(),+ /*bundled_skills_enabled*/ true,+ );+ let request = skills_service.for_request();+ let input = |cwd: &TempDir, config_layer_stack| {+ HostSkillsLoadInput::new(+ cwd.path().abs(),+ Vec::new(),+ config_layer_stack,+ /*bundled_skills_enabled*/ true,+ )+ };++ write_user_skill(&codex_home, "first", "first-skill", "first skill");+ let first = request+ .snapshot_for_cwd(+ &input(&first_cwd, config_layer_stack.clone()),+ /*force_reload*/ false,+ Some(Arc::clone(&LOCAL_FS)),+ )+ .await;++ write_user_skill(&codex_home, "second", "second-skill", "second skill");+ let second = request+ .snapshot_for_cwd(+ &input(&second_cwd, disabled_config_layer_stack),+ /*force_reload*/ false,+ Some(Arc::clone(&LOCAL_FS)),+ )+ .await;+ assert_eq!(second.outcome().skills, first.outcome().skills);+ let first_skill_path = first+ .outcome()+ .skills+ .iter()+ .find(|skill| skill.name == "first-skill")+ .expect("first skill should be discovered")+ .path_to_skills_md+ .clone();+ assert!(!first.outcome().disabled_paths.contains(&first_skill_path));+ assert!(second.outcome().disabled_paths.contains(&first_skill_path));++ let third = skills_service+ .for_request()+ .snapshot_for_cwd(+ &input(&first_cwd, config_layer_stack),+ /*force_reload*/ true,+ Some(Arc::clone(&LOCAL_FS)),+ )+ .await;+ assert!(+ third+ .outcome()+ .skills+ .iter()+ .any(|skill| skill.name == "second-skill")+ );+}+#[tokio::test]async fn skills_for_config_refreshes_cache_when_remote_plugin_id_changes() {let codex_home = tempfile::tempdir().expect("tempdir");@@ -344,6 +414,7 @@ async fn skills_for_config_refreshes_cache_when_remote_plugin_id_changes() {.clone().with_plugin_skill_snapshots(/*plugin_skill_snapshots*/ None);let listing_snapshot = skills_service+ .for_request().snapshot_for_cwd(&listing_input,/*force_reload*/ false,@@ -405,6 +476,7 @@ async fn set_extra_roots_replaces_runtime_roots_and_clears_cache() {bundled_skills_enabled_from_stack(&config_layer_stack),);let empty_snapshot = skills_service+ .for_request().snapshot_for_cwd(&skills_input,/*force_reload*/ false,@@ -430,6 +502,7 @@ async fn set_extra_roots_replaces_runtime_roots_and_clears_cache() {skills_service.set_extra_roots(vec![extra_skills_root.abs()]);let runtime_snapshot = skills_service+ .for_request().snapshot_for_cwd(&skills_input,/*force_reload*/ false,@@ -446,6 +519,7 @@ async fn set_extra_roots_replaces_runtime_roots_and_clears_cache() {skills_service.set_extra_roots(vec![extra_root.path().join("missing-skills").abs()]);let replaced_snapshot = skills_service+ .for_request().snapshot_for_cwd(&skills_input,/*force_reload*/ false,@@ -603,6 +677,7 @@ async fn skills_for_cwd_loads_repo_and_user_roots_with_local_fs() {);let snapshot = skills_service+ .for_request().snapshot_for_cwd(&skills_input,/*force_reload*/ true,@@ -673,6 +748,7 @@ async fn skills_for_cwd_without_fs_skips_repo_roots() {);let snapshot = skills_service+ .for_request().snapshot_for_cwd(&skills_input, /*force_reload*/ true, /*fs*/ None).await;let outcome = snapshot.outcome();@@ -742,9 +818,10 @@ async fn skills_for_cwd_uses_cached_result_until_force_reload() {let config_input = base_input.clone().with_plugin_skill_snapshots(Some(test_plugin_skill_snapshots()));+ let request = skills_service.for_request();let (config_snapshot, snapshot_a) = tokio::join!(skills_service.snapshot_for_config(&config_input, Some(Arc::clone(&LOCAL_FS))),- skills_service.snapshot_for_cwd(+ request.snapshot_for_cwd(&base_input,/*force_reload*/ false,Some(Arc::clone(&LOCAL_FS)),@@ -765,6 +842,7 @@ async fn skills_for_cwd_uses_cached_result_until_force_reload() {write_user_skill(&codex_home, "late", "late-skill", "added after cache");let snapshot_b = skills_service+ .for_request().snapshot_for_cwd(&base_input,/*force_reload*/ false,@@ -780,6 +858,7 @@ async fn skills_for_cwd_uses_cached_result_until_force_reload() {);let snapshot_reloaded = skills_service+ .for_request().snapshot_for_cwd(&base_input,/*force_reload*/ true,@@ -825,6 +904,7 @@ async fn skills_for_config_ignores_cwd_cache_when_session_flags_reenable_skill());let parent_snapshot = skills_service+ .for_request().snapshot_for_cwd(&parent_input,/*force_reload*/ true,diff --git a/codex-rs/ext/skills/src/lib.rs b/codex-rs/ext/skills/src/lib.rsindex 6c770c28f3..5cf48c811c 100644--- a/codex-rs/ext/skills/src/lib.rs+++ b/codex-rs/ext/skills/src/lib.rs@@ -32,6 +32,7 @@ pub use host_outcome::SkillLoadOutcome;pub use host_prompt::HostSkillPrompts;pub use host_prompt::InjectedHostSkillPrompts;pub use host_service::HostSkillsLoadInput;+pub use host_service::HostSkillsRequest;pub use host_service::HostSkillsService;pub use host_service::bundled_skills_enabled_from_stack;pub use host_snapshot::HostSkillsSnapshot;diff --git a/codex-rs/ext/skills/src/loader/host_merge.rs b/codex-rs/ext/skills/src/loader/host_merge.rsindex 9db69bb8a7..ac309afe85 100644--- a/codex-rs/ext/skills/src/loader/host_merge.rs+++ b/codex-rs/ext/skills/src/loader/host_merge.rs@@ -11,6 +11,7 @@ use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;use codex_utils_plugins::PluginSkillRoot;use codex_utils_plugins::migrated_command_skills_root;+use futures::FutureExt;use futures::StreamExt;use tokio::sync::OnceCell;use tokio::sync::Semaphore;@@ -20,12 +21,31 @@ use super::MAX_CONCURRENT_ROOT_SCANS;use super::host::HostSkillRootSnapshot;use super::load_host_skill_root;use crate::SkillLoadOutcome;+use crate::host_service::RequestSkillRootSnapshots;+use crate::host_service::config_skill_root_cache_key;pub(crate) async fn load_and_merge_host_skill_roots(roots: Vec<HostSkillRoot>,root_scan_slots: &Semaphore,restriction_product: Option<Product>,plugin_skill_snapshots: Option<&SkillRootSnapshots<PluginSkillRoot>>,+) -> SkillLoadOutcome {+ load_and_merge_host_skill_roots_with_request_snapshots(+ roots,+ root_scan_slots,+ restriction_product,+ plugin_skill_snapshots,+ /*request_root_snapshots*/ None,+ )+ .await+}++pub(crate) async fn load_and_merge_host_skill_roots_with_request_snapshots(+ roots: Vec<HostSkillRoot>,+ root_scan_slots: &Semaphore,+ restriction_product: Option<Product>,+ plugin_skill_snapshots: Option<&SkillRootSnapshots<PluginSkillRoot>>,+ request_root_snapshots: Option<&RequestSkillRootSnapshots>,) -> SkillLoadOutcome {let migrated_command_roots_by_plugin = roots.iter()@@ -42,42 +62,63 @@ pub(crate) async fn load_and_merge_host_skill_roots(.cloned();let plugin_skill_root = root.plugin_skill_root();let file_system = Arc::clone(&root.file_system);- let _root_scan_slot = root_scan_slots- .acquire()- .await- .unwrap_or_else(|_| unreachable!());- let cached_snapshot = plugin_skill_root- .as_ref()- .and_then(|plugin_skill_root| plugin_skill_snapshots?.get(plugin_skill_root));- let snapshot = match cached_snapshot {- Some(snapshot) => HostSkillRootSnapshot {- root: snapshot.root,- skills: snapshot.skills,- skill_discovery_path_by_path: snapshot.skill_discovery_path_by_path,- errors: snapshot.errors,- file_system: Arc::clone(&file_system),- is_agent_plugin: snapshot.is_agent_plugin,- },- None => {- let snapshot = load_host_skill_root(root).await;- if let Some(plugin_skill_snapshots) = plugin_skill_snapshots- && let Some(plugin_skill_root) = plugin_skill_root- {- plugin_skill_snapshots.insert(- plugin_skill_root,- LoadedSkillRoot {- root: snapshot.root.clone(),- skills: snapshot.skills.clone(),- skill_discovery_path_by_path: Arc::clone(- &snapshot.skill_discovery_path_by_path,- ),- errors: snapshot.errors.clone(),- is_agent_plugin: snapshot.is_agent_plugin,- },- );+ let request_snapshot = if plugin_skill_root.is_none() {+ request_root_snapshots.map(|snapshots| {+ Arc::clone(+ snapshots+ .write()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .entry(config_skill_root_cache_key(&root))+ .or_insert_with(|| Arc::new(OnceCell::new())),+ )+ })+ } else {+ None+ };+ let load = async {+ let _root_scan_slot = root_scan_slots+ .acquire()+ .await+ .unwrap_or_else(|_| unreachable!());+ let cached_snapshot = plugin_skill_root+ .as_ref()+ .and_then(|plugin_skill_root| plugin_skill_snapshots?.get(plugin_skill_root));+ match cached_snapshot {+ Some(snapshot) => HostSkillRootSnapshot {+ root: snapshot.root,+ skills: snapshot.skills,+ skill_discovery_path_by_path: snapshot.skill_discovery_path_by_path,+ errors: snapshot.errors,+ file_system: Arc::clone(&file_system),+ is_agent_plugin: snapshot.is_agent_plugin,+ },+ None => {+ let snapshot = load_host_skill_root(root).await;+ if let Some(plugin_skill_snapshots) = plugin_skill_snapshots+ && let Some(plugin_skill_root) = plugin_skill_root+ {+ plugin_skill_snapshots.insert(+ plugin_skill_root,+ LoadedSkillRoot {+ root: snapshot.root.clone(),+ skills: snapshot.skills.clone(),+ skill_discovery_path_by_path: Arc::clone(+ &snapshot.skill_discovery_path_by_path,+ ),+ errors: snapshot.errors.clone(),+ is_agent_plugin: snapshot.is_agent_plugin,+ },+ );+ }+ snapshot}- snapshot}+ }+ .boxed();+ let snapshot = if let Some(snapshot) = request_snapshot {+ snapshot.get_or_init(|| load).await.clone()+ } else {+ load.await};let migrated_command_root = match (plugin_root.as_ref(), migrated_command_root) {(Some(plugin_root), Some(migrated_command_root)) => Some(diff --git a/codex-rs/ext/skills/src/loader/mod.rs b/codex-rs/ext/skills/src/loader/mod.rsindex a94cc6a0c3..5d7476bfe3 100644--- a/codex-rs/ext/skills/src/loader/mod.rs+++ b/codex-rs/ext/skills/src/loader/mod.rs@@ -10,8 +10,10 @@ mod namespace;pub(crate) use environment::load_environment_skills_from_discovery;pub(crate) use environment::load_environment_skills_from_root;pub use host::HostSkillRoot;+pub(crate) use host::HostSkillRootSnapshot;pub(crate) use host::load_host_skill_root;pub(crate) use host_merge::load_and_merge_host_skill_roots;+pub(crate) use host_merge::load_and_merge_host_skill_roots_with_request_snapshots;pub(crate) const MAX_CONCURRENT_ROOT_SCANS: usize = 8;pub(super) const SKILLS_FILENAME: &str = "SKILL.md";