Lightweight coding agent that runs in your terminal
Rust
Move host skill root resolution into the skills extension (#36943)
felixxia-oai1a7519fa070d
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex f5ec6bc45b..03b585f717 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2922,7 +2922,6 @@ dependencies = ["codex-utils-absolute-path","codex-utils-path-uri","codex-utils-plugins",- "dirs","dunce","futures","pretty_assertions",@@ -4115,6 +4114,7 @@ dependencies = ["codex-utils-path-uri","codex-utils-plugins","codex-utils-string",+ "dirs","dunce","futures","insta",diff --git a/codex-rs/core-skills/Cargo.toml b/codex-rs/core-skills/Cargo.tomlindex d175fceec9..61b16ab236 100644--- a/codex-rs/core-skills/Cargo.toml+++ b/codex-rs/core-skills/Cargo.toml@@ -27,7 +27,6 @@ codex-skills = { workspace = true }codex-utils-absolute-path = { workspace = true }codex-utils-path-uri = { workspace = true }codex-utils-plugins = { workspace = true }-dirs = { workspace = true }dunce = { workspace = true }futures = { workspace = true }serde = { workspace = true, features = ["derive"] }@@ -35,10 +34,10 @@ serde_json = { workspace = true }serde_yaml = { workspace = true }shlex = { workspace = true }tokio = { workspace = true, features = ["fs", "macros", "rt"] }-toml = { workspace = true }tracing = { workspace = true }zip = { workspace = true }[dev-dependencies]pretty_assertions = { workspace = true }tempfile = { workspace = true }+toml = { workspace = true }diff --git a/codex-rs/core-skills/src/lib.rs b/codex-rs/core-skills/src/lib.rsindex 8b70ad57ae..71d2ef4584 100644--- a/codex-rs/core-skills/src/lib.rs+++ b/codex-rs/core-skills/src/lib.rs@@ -7,7 +7,6 @@ pub mod model;pub mod remote;mod root_loader;mod skill_instructions;-pub mod system;pub(crate) use invocation_utils::build_implicit_skill_path_indexes;pub use invocation_utils::detect_implicit_skill_invocation_for_command;diff --git a/codex-rs/core-skills/src/loader.rs b/codex-rs/core-skills/src/loader.rsindex f8e866a23a..347d415419 100644--- a/codex-rs/core-skills/src/loader.rs+++ b/codex-rs/core-skills/src/loader.rs@@ -13,14 +13,7 @@ use crate::model::SkillLoadOutcome;use crate::model::SkillMetadata;use crate::model::SkillPolicy;use crate::model::SkillToolDependency;-use crate::system::system_cache_root_dir;-use codex_config::ConfigLayerSource;-use codex_config::ConfigLayerStack;-use codex_config::default_project_root_markers;-use codex_config::merge_toml_values;-use codex_config::project_root_markers_from_config;use codex_exec_server::ExecutorFileSystem;-use codex_exec_server::LOCAL_FS;use codex_protocol::protocol::Product;use codex_protocol::protocol::SkillScope;use codex_skills::ParsedSkillFrontmatter;@@ -33,9 +26,7 @@ use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_absolute_path::AbsolutePathBufGuard;use codex_utils_path_uri::PathUri;use codex_utils_plugins::PluginIdentity;-use codex_utils_plugins::PluginSkillRoot;use codex_utils_plugins::SkillDiscoveryMode;-use dirs::home_dir;use discovery::DirectorySymlinkPolicy;use discovery::DiscoveredSkill;use discovery::HiddenDirectoryPolicy;@@ -48,13 +39,11 @@ use futures::FutureExt;use futures::StreamExt;use namespace::SkillNamespaceResolver;use serde::Deserialize;-use std::collections::HashSet;use std::error::Error;use std::fmt;use std::io;use std::sync::Arc;use tokio::sync::Semaphore;-use toml::Value as TomlValue;use tracing::error;// TODO(anp): Tune this eight-scan limit after revisiting byte-based backpressure.@@ -103,10 +92,8 @@ struct DependencyTool {}const SKILLS_FILENAME: &str = "SKILL.md";-const AGENTS_DIR_NAME: &str = ".agents";const SKILLS_METADATA_DIR: &str = "agents";const SKILLS_METADATA_FILENAME: &str = "openai.yaml";-const SKILLS_DIR_NAME: &str = "skills";const MAX_NAME_LEN: usize = 64;const MAX_QUALIFIED_NAME_LEN: usize = 128;const MAX_DESCRIPTION_LEN: usize = 1024;@@ -119,9 +106,6 @@ const MAX_DEPENDENCY_URL_LEN: usize = MAX_DESCRIPTION_LEN;// Traversal depth from the skills root.const MAX_SCAN_DEPTH: usize = 6;const MAX_SKILLS_DIRS_PER_ROOT: usize = 2000;-// Keep ancestor metadata probes within one remote round trip for typical project hierarchies while-// leaving room for other startup discovery on the shared exec-server transport.-const MAX_CONCURRENT_ANCESTOR_PROBES: usize = 256;struct ResolvedDiscoveredSkill {skill: DiscoveredSkill,@@ -197,277 +181,6 @@ pub(crate) async fn load_skill_root(root: SkillRoot) -> SkillRootSnapshot {}}-pub async fn skill_roots(- fs: Option<Arc<dyn ExecutorFileSystem>>,- config_layer_stack: &ConfigLayerStack,- cwd: &AbsolutePathBuf,- plugin_skill_roots: Vec<PluginSkillRoot>,- extra_skill_roots: Vec<AbsolutePathBuf>,-) -> Vec<SkillRoot> {- let home_dir =- home_dir().and_then(|path| AbsolutePathBuf::from_absolute_path_checked(path).ok());- skill_roots_with_home_dir(- fs,- config_layer_stack,- cwd,- home_dir.as_ref(),- plugin_skill_roots,- extra_skill_roots,- )- .await-}--async fn skill_roots_with_home_dir(- fs: Option<Arc<dyn ExecutorFileSystem>>,- config_layer_stack: &ConfigLayerStack,- cwd: &AbsolutePathBuf,- home_dir: Option<&AbsolutePathBuf>,- plugin_skill_roots: Vec<PluginSkillRoot>,- extra_skill_roots: Vec<AbsolutePathBuf>,-) -> Vec<SkillRoot> {- let mut roots = skill_roots_from_layer_stack_inner(config_layer_stack, home_dir, fs.clone());- roots.extend(plugin_skill_roots.into_iter().map(|root| SkillRoot {- path: root.path,- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(root.plugin_identity),- plugin_namespace: Some(root.plugin_namespace),- plugin_root: Some(root.plugin_root),- discovery_mode: root.discovery_mode,- }));- roots.extend(extra_skill_roots.into_iter().map(|path| SkillRoot {- path,- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }));- roots.extend(repo_agents_skill_roots(fs, config_layer_stack, cwd).await);- dedupe_skill_roots_by_path(&mut roots);- roots-}--fn skill_roots_from_layer_stack_inner(- config_layer_stack: &ConfigLayerStack,- home_dir: Option<&AbsolutePathBuf>,- repo_fs: Option<Arc<dyn ExecutorFileSystem>>,-) -> Vec<SkillRoot> {- let mut roots = Vec::new();-- for layer in config_layer_stack.all_layers_high_to_low() {- let Some(config_folder) = layer.config_folder() else {- continue;- };-- match &layer.name {- ConfigLayerSource::Project { .. } => {- if let Some(repo_fs) = &repo_fs {- roots.push(SkillRoot {- path: config_folder.join(SKILLS_DIR_NAME),- scope: SkillScope::Repo,- file_system: Arc::clone(repo_fs),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- });- }- }- ConfigLayerSource::User { .. } => {- // Deprecated user skills location (`$CODEX_HOME/skills`), kept for backward- // compatibility.- roots.push(SkillRoot {- path: config_folder.join(SKILLS_DIR_NAME),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- });-- // `$HOME/.agents/skills` (user-installed skills).- if let Some(home_dir) = home_dir {- roots.push(SkillRoot {- path: home_dir.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- });- }-- // Embedded system skills are cached under `$CODEX_HOME/skills/.system` and are a- // special case (not a config layer).- roots.push(SkillRoot {- path: system_cache_root_dir(&config_folder),- scope: SkillScope::System,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- });- }- ConfigLayerSource::System { .. } => {- // The system config layer lives under `/etc/codex/` on Unix, so treat- // `/etc/codex/skills` as admin-scoped skills.- roots.push(SkillRoot {- path: config_folder.join(SKILLS_DIR_NAME),- scope: SkillScope::Admin,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- });- }- ConfigLayerSource::Mdm { .. }- | ConfigLayerSource::EnterpriseManaged { .. }- | ConfigLayerSource::SessionFlags- | ConfigLayerSource::LegacyManagedConfigTomlFromFile { .. }- | ConfigLayerSource::LegacyManagedConfigTomlFromMdm => {}- }- }-- roots-}--async fn repo_agents_skill_roots(- fs: Option<Arc<dyn ExecutorFileSystem>>,- config_layer_stack: &ConfigLayerStack,- cwd: &AbsolutePathBuf,-) -> Vec<SkillRoot> {- let Some(fs) = fs else {- return Vec::new();- };- let project_root_markers = project_root_markers_from_stack(config_layer_stack);- let project_root = find_project_root(fs.as_ref(), cwd, &project_root_markers).await;- let dirs = dirs_between_project_root_and_cwd(cwd, &project_root);- let mut roots = Vec::new();- let mut results = futures::stream::iter(dirs)- .map(|dir| {- let fs = Arc::clone(&fs);- async move {- let agents_skills = dir.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME);- let agents_skills_uri = PathUri::from_abs_path(&agents_skills);- let result = fs.get_metadata(&agents_skills_uri, /*sandbox*/ None).await;- (agents_skills, result)- }- })- .buffered(MAX_CONCURRENT_ANCESTOR_PROBES);- while let Some((agents_skills, result)) = results.next().await {- match result {- Ok(metadata) if metadata.is_directory => roots.push(SkillRoot {- path: agents_skills,- scope: SkillScope::Repo,- file_system: Arc::clone(&fs),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }),- Ok(_) => {}- Err(err) if err.kind() == io::ErrorKind::NotFound => {}- Err(err) => {- tracing::warn!(- "failed to stat repo skills root {}: {err:#}",- agents_skills.display()- );- }- }- }- roots-}--fn project_root_markers_from_stack(config_layer_stack: &ConfigLayerStack) -> Vec<String> {- let mut merged = TomlValue::Table(toml::map::Map::new());- for layer in config_layer_stack.layers_low_to_high() {- if matches!(layer.name, ConfigLayerSource::Project { .. }) {- continue;- }- merge_toml_values(&mut merged, &layer.config);- }-- match project_root_markers_from_config(&merged) {- Ok(Some(markers)) => markers,- Ok(None) => default_project_root_markers(),- Err(err) => {- tracing::warn!("invalid project_root_markers: {err}");- default_project_root_markers()- }- }-}--async fn find_project_root(- fs: &dyn ExecutorFileSystem,- cwd: &AbsolutePathBuf,- project_root_markers: &[String],-) -> AbsolutePathBuf {- if project_root_markers.is_empty() {- return cwd.clone();- }-- let mut probes = Vec::new();- for ancestor in cwd.ancestors() {- for marker in project_root_markers {- let marker_path = ancestor.join(marker);- probes.push((ancestor.clone(), marker_path));- }- }- let mut results = futures::stream::iter(probes)- .map(|(ancestor, marker_path)| async move {- let marker_path_uri = PathUri::from_abs_path(&marker_path);- let result = fs.get_metadata(&marker_path_uri, /*sandbox*/ None).await;- (ancestor, marker_path, result)- })- .buffered(MAX_CONCURRENT_ANCESTOR_PROBES);- while let Some((ancestor, marker_path, result)) = results.next().await {- match result {- Ok(_) => return ancestor,- Err(err) if err.kind() == io::ErrorKind::NotFound => {}- Err(err) => {- tracing::warn!(- "failed to stat project root marker {}: {err:#}",- marker_path.display()- );- }- }- }-- cwd.clone()-}--fn dirs_between_project_root_and_cwd(- cwd: &AbsolutePathBuf,- project_root: &AbsolutePathBuf,-) -> Vec<AbsolutePathBuf> {- let mut dirs = cwd- .ancestors()- .scan(false, |done, dir| {- if *done {- None- } else {- if &dir == project_root {- *done = true;- }- Some(dir)- }- })- .collect::<Vec<_>>();- dirs.reverse();- dirs-}--fn dedupe_skill_roots_by_path(roots: &mut Vec<SkillRoot>) {- let mut seen: HashSet<AbsolutePathBuf> = HashSet::new();- roots.retain(|root| seen.insert(root.path.clone()));-}-async fn canonicalize_for_skill_identity(fs: &dyn ExecutorFileSystem,path: &AbsolutePathBuf,@@ -889,24 +602,6 @@ fn resolve_required_str(resolve_str(Some(value), max_len, field)}-#[cfg(test)]-pub(crate) async fn skill_roots_from_layer_stack(- fs: Arc<dyn ExecutorFileSystem>,- config_layer_stack: &ConfigLayerStack,- cwd: &AbsolutePathBuf,- home_dir: Option<&AbsolutePathBuf>,-) -> Vec<SkillRoot> {- skill_roots_with_home_dir(- Some(fs),- config_layer_stack,- cwd,- home_dir,- Vec::new(),- Vec::new(),- )- .await-}-#[cfg(test)]#[path = "loader_tests.rs"]mod tests;diff --git a/codex-rs/core-skills/src/loader_tests.rs b/codex-rs/core-skills/src/loader_tests.rsindex 51185a7c42..055fa8a830 100644--- a/codex-rs/core-skills/src/loader_tests.rs+++ b/codex-rs/core-skills/src/loader_tests.rs@@ -1,9 +1,4 @@use super::*;-use codex_config::CONFIG_TOML_FILE;-use codex_config::ConfigLayerEntry;-use codex_config::ConfigLayerStack;-use codex_config::ConfigRequirements;-use codex_config::ConfigRequirementsToml;use codex_exec_server::CopyOptions;use codex_exec_server::CreateDirectoryOptions;use codex_exec_server::ExecutorFileSystem;@@ -28,46 +23,23 @@ use std::fs;use std::path::Path;use std::path::PathBuf;use std::sync::Arc;-use std::sync::Mutex;use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;use tempfile::TempDir;use tokio::sync::Notify;use tokio::sync::Semaphore;-use toml::Value as TomlValue;const REPO_ROOT_CONFIG_DIR_NAME: &str = ".codex";--struct TestConfig {- cwd: AbsolutePathBuf,- config_layer_stack: ConfigLayerStack,-}+const SKILLS_DIR_NAME: &str = "skills";struct BlockingRepoSkillRootFileSystem {inner: Arc<dyn ExecutorFileSystem>,- metadata_calls: Arc<BlockingMetadataCalls>,blocked_walk_root: Option<PathUri>,blocked_walk_gate: Semaphore,walks_started: AtomicUsize,walk_started: Notify,}-struct BlockingMetadataCalls {- paths: Mutex<Vec<PathUri>>,- started: Notify,- release: Semaphore,-}--impl Default for BlockingMetadataCalls {- fn default() -> Self {- Self {- paths: Mutex::new(Vec::new()),- started: Notify::new(),- release: Semaphore::new(0),- }- }-}-impl ExecutorFileSystem for BlockingRepoSkillRootFileSystem {fn canonicalize<'a>(&'a self,@@ -116,29 +88,7 @@ impl ExecutorFileSystem for BlockingRepoSkillRootFileSystem {path: &'a PathUri,sandbox: Option<&'a FileSystemSandboxContext>,) -> ExecutorFileSystemFuture<'a, FileMetadata> {- let repo_skill_root_suffix = Path::new(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME);- let Ok(path_abs) = path.to_abs_path() else {- return self.inner.get_metadata(path, sandbox);- };- if !path_abs.ends_with(repo_skill_root_suffix) {- return self.inner.get_metadata(path, sandbox);- }-- self.metadata_calls- .paths- .lock()- .expect("metadata paths lock")- .push(path.clone());- self.metadata_calls.started.notify_one();- Box::pin(async move {- self.metadata_calls- .release- .acquire()- .await- .expect("metadata release semaphore")- .forget();- self.inner.get_metadata(path, sandbox).await- })+ self.inner.get_metadata(path, sandbox)}fn read_directory<'a>(@@ -191,118 +141,37 @@ impl ExecutorFileSystem for BlockingRepoSkillRootFileSystem {}}-async fn make_config(codex_home: &TempDir) -> TestConfig {- make_config_for_cwd(codex_home, codex_home.path().to_path_buf()).await-}--fn config_file(path: PathBuf) -> AbsolutePathBuf {- path.abs()-}--fn project_layers_for_cwd(cwd: &Path) -> Vec<ConfigLayerEntry> {- let cwd_dir = if cwd.is_dir() {- cwd.to_path_buf()- } else {- cwd.parent()- .expect("file cwd should have a parent directory")- .to_path_buf()- };- let project_root = cwd_dir- .ancestors()- .find(|ancestor| ancestor.join(".git").exists())- .unwrap_or(cwd_dir.as_path())- .to_path_buf();-- let mut layers = cwd_dir- .ancestors()- .scan(false, |done, dir| {- if *done {- None- } else {- if dir == project_root {- *done = true;- }- Some(dir.to_path_buf())- }- })- .collect::<Vec<_>>();- layers.reverse();-- layers- .into_iter()- .filter_map(|dir| {- let dot_codex = dir.join(REPO_ROOT_CONFIG_DIR_NAME);- dot_codex.is_dir().then(|| {- ConfigLayerEntry::new(- ConfigLayerSource::Project {- dot_codex_folder: dot_codex.abs(),- },- TomlValue::Table(toml::map::Map::new()),- )- })- })- .collect()-}--async fn make_config_for_cwd(codex_home: &TempDir, cwd: PathBuf) -> TestConfig {- let user_config_path = codex_home.path().join(CONFIG_TOML_FILE);- let system_config_path = codex_home.path().join("etc/codex/config.toml");- fs::create_dir_all(- system_config_path- .parent()- .expect("system config path should have a parent"),- )- .expect("create fake system config dir");-- let mut layers = vec![- ConfigLayerEntry::new(- ConfigLayerSource::System {- file: config_file(system_config_path),- },- TomlValue::Table(toml::map::Map::new()),- ),- ConfigLayerEntry::new(- ConfigLayerSource::User {- file: config_file(user_config_path),- profile: None,- },- TomlValue::Table(toml::map::Map::new()),- ),- ];- layers.extend(project_layers_for_cwd(&cwd));-- let cwd_abs = cwd.abs();- TestConfig {- cwd: cwd_abs,- config_layer_stack: ConfigLayerStack::new(- layers,- ConfigRequirements::default(),- ConfigRequirementsToml::default(),- )- .expect("valid config layer stack"),- }-}--async fn load_skills_for_test(config: &TestConfig) -> SkillLoadOutcome {- // Keep unit tests hermetic by never scanning the real `$HOME/.agents/skills`.+async fn load_skills_for_test<I>(roots: I) -> SkillLoadOutcome+where+ I: IntoIterator<Item = SkillRoot> + Send,+ I::IntoIter: Send,+{super::load_skills_from_roots(- super::skill_roots_from_layer_stack(- Arc::clone(&LOCAL_FS),- &config.config_layer_stack,- &config.cwd,- /*home_dir*/ None,- )- .await,+ roots,/*plugin_skill_snapshots*/ None,Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),).await}-fn mark_as_git_repo(dir: &Path) {- // Config/project-root discovery only checks for the presence of `.git` (file or dir),- // so we can avoid shelling out to `git init` in tests.- fs::write(dir.join(".git"), "gitdir: fake\n").unwrap();+fn local_skill_root(path: &Path, scope: SkillScope) -> SkillRoot {+ SkillRoot {+ path: path.abs(),+ scope,+ file_system: Arc::clone(&LOCAL_FS),+ plugin_identity: None,+ plugin_namespace: None,+ plugin_root: None,+ discovery_mode: SkillDiscoveryMode::Recursive,+ }+}++async fn load_user_skills_for_test(codex_home: &TempDir) -> SkillLoadOutcome {+ load_skills_for_test([local_skill_root(+ &codex_home.path().join(SKILLS_DIR_NAME),+ SkillScope::User,+ )])+ .await}fn normalized(path: &Path) -> AbsolutePathBuf {@@ -310,208 +179,6 @@ fn normalized(path: &Path) -> AbsolutePathBuf {.unwrap_or_else(|_| path.to_path_buf()).abs()}--#[tokio::test]-async fn skill_roots_from_layer_stack_maps_user_to_user_and_system_cache_and_system_to_admin()--> anyhow::Result<()> {- let tmp = tempfile::tempdir()?;-- let system_folder = tmp.path().join("etc/codex");- let home_folder = tmp.path().join("home");- let user_folder = home_folder.join("codex");- fs::create_dir_all(&system_folder)?;- fs::create_dir_all(&user_folder)?;-- // The file path doesn't need to exist; it's only used to derive the config folder.- let system_file = system_folder.join("config.toml").abs();- let user_file = user_folder.join("config.toml").abs();-- let layers = vec![- ConfigLayerEntry::new(- ConfigLayerSource::System { file: system_file },- TomlValue::Table(toml::map::Map::new()),- ),- ConfigLayerEntry::new(- ConfigLayerSource::User {- file: user_file,- profile: None,- },- TomlValue::Table(toml::map::Map::new()),- ),- ];- let stack = ConfigLayerStack::new(- layers,- ConfigRequirements::default(),- ConfigRequirementsToml::default(),- )?;-- let home_folder_abs = home_folder.abs();- let got = skill_roots_from_layer_stack(- Arc::clone(&LOCAL_FS),- &stack,- &home_folder_abs,- Some(&home_folder_abs),- )- .await- .into_iter()- .map(|root| (root.scope, root.path.to_path_buf()))- .collect::<Vec<_>>();-- assert_eq!(- got,- vec![- (SkillScope::User, user_folder.join("skills")),- (- SkillScope::User,- home_folder.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME)- ),- (- SkillScope::System,- user_folder.join("skills").join(".system")- ),- (SkillScope::Admin, system_folder.join("skills")),- ]- );-- Ok(())-}--#[tokio::test]-async fn skill_roots_from_layer_stack_includes_disabled_project_layers() -> anyhow::Result<()> {- let tmp = tempfile::tempdir()?;-- let home_folder = tmp.path().join("home");- let user_folder = home_folder.join("codex");- fs::create_dir_all(&user_folder)?;-- let project_root = tmp.path().join("repo");- let dot_codex = project_root.join(".codex");- fs::create_dir_all(&dot_codex)?;-- let user_file = user_folder.join("config.toml").abs();- let project_dot_codex = dot_codex.abs();-- let layers = vec![- ConfigLayerEntry::new(- ConfigLayerSource::User {- file: user_file,- profile: None,- },- TomlValue::Table(toml::map::Map::new()),- ),- ConfigLayerEntry::new_disabled(- ConfigLayerSource::Project {- dot_codex_folder: project_dot_codex,- },- TomlValue::Table(toml::map::Map::new()),- "marked untrusted",- ),- ];- let stack = ConfigLayerStack::new(- layers,- ConfigRequirements::default(),- ConfigRequirementsToml::default(),- )?;-- let home_folder_abs = home_folder.abs();- let project_root_abs = project_root.abs();- let got = skill_roots_from_layer_stack(- Arc::clone(&LOCAL_FS),- &stack,- &project_root_abs,- Some(&home_folder_abs),- )- .await- .into_iter()- .map(|root| (root.scope, root.path.to_path_buf()))- .collect::<Vec<_>>();-- assert_eq!(- got,- vec![- (SkillScope::Repo, dot_codex.join("skills")),- (SkillScope::User, user_folder.join("skills")),- (- SkillScope::User,- home_folder.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME)- ),- (- SkillScope::System,- user_folder.join("skills").join(".system")- ),- ]- );-- Ok(())-}--#[tokio::test]-async fn loads_skills_from_home_agents_dir_for_user_scope() -> anyhow::Result<()> {- let tmp = tempfile::tempdir()?;-- let home_folder = tmp.path().join("home");- let user_folder = home_folder.join("codex");- fs::create_dir_all(&user_folder)?;-- let user_file = user_folder.join("config.toml").abs();- let layers = vec![ConfigLayerEntry::new(- ConfigLayerSource::User {- file: user_file,- profile: None,- },- TomlValue::Table(toml::map::Map::new()),- )];- let stack = ConfigLayerStack::new(- layers,- ConfigRequirements::default(),- ConfigRequirementsToml::default(),- )?;-- let skill_path = write_skill_at(- &home_folder.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME),- "agents-home",- "agents-home-skill",- "from home agents",- );-- let home_folder_abs = home_folder.abs();- let roots = skill_roots_from_layer_stack(- Arc::clone(&LOCAL_FS),- &stack,- &home_folder_abs,- Some(&home_folder_abs),- )- .await;- let outcome = load_skills_from_roots(- roots,- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "agents-home-skill".to_string(),- description: "from home agents".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );-- Ok(())-}-fn write_skill(codex_home: &TempDir, dir: &str, name: &str, description: &str) -> PathBuf {write_skill_at(&codex_home.path().join("skills"), dir, name, description)}@@ -635,8 +302,7 @@ async fn loads_skill_dependencies_metadata_from_yaml() {"#,);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -707,8 +373,7 @@ interface:"##,);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -758,8 +423,7 @@ policy:"#,);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -790,8 +454,7 @@ policy: {}"#,);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -829,8 +492,7 @@ policy:"#,);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -939,8 +601,7 @@ async fn loads_skills_via_symlinked_subdir_for_user_scope() {fs::create_dir_all(codex_home.path().join("skills")).unwrap();symlink_dir(shared.path(), &codex_home.path().join("skills/shared"));- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -1002,8 +663,7 @@ async fn ignores_symlinked_skill_file_for_user_scope() {fs::create_dir_all(&skill_dir).unwrap();symlink_file(&shared_skill_path, &skill_dir.join(SKILLS_FILENAME));- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -1026,8 +686,7 @@ async fn does_not_loop_on_symlink_cycle_for_user_scope() {let skill_path = write_skill_at(&cycle_dir, "demo", "cycle-skill", "still loads");- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -1102,9 +761,7 @@ async fn loads_skills_via_symlinked_subdir_for_admin_scope() {#[tokio::test]#[cfg(unix)]async fn loads_skills_via_symlinked_subdir_for_repo_scope() {- let codex_home = tempfile::tempdir().expect("tempdir");let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());let shared = tempfile::tempdir().expect("tempdir");let linked_skill_path = write_skill_at(shared.path(), "demo", "repo-linked-skill", "from link");@@ -1115,8 +772,8 @@ async fn loads_skills_via_symlinked_subdir_for_repo_scope() {fs::create_dir_all(&repo_skills_root).unwrap();symlink_dir(shared.path(), &repo_skills_root.join("shared"));- let cfg = make_config_for_cwd(&codex_home, repo_dir.path().to_path_buf()).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome =+ load_skills_for_test([local_skill_root(&repo_skills_root, SkillScope::Repo)]).await;assert!(outcome.errors.is_empty(),@@ -1233,9 +890,7 @@ async fn respects_max_scan_depth_for_user_scope() {async fn loads_valid_skill() {let codex_home = tempfile::tempdir().expect("tempdir");let skill_path = write_skill(&codex_home, "demo", "demo-skill", "does things\ncarefully");- let cfg = make_config(&codex_home).await;-- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1266,9 +921,7 @@ async fn falls_back_to_directory_name_when_skill_name_is_missing() {"directory-derived","description: fallback name",);- let cfg = make_config(&codex_home).await;-- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),@@ -1729,8 +1382,7 @@ async fn loads_short_description_from_metadata() {let skill_path = skill_dir.join(SKILLS_FILENAME);fs::write(&skill_path, contents).unwrap();- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1762,8 +1414,7 @@ async fn loads_unquoted_description_containing_colon_space() {"name: colon-description\ndescription: AWS deployment patterns: ECS Fargate, Lambda, and S3",);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1795,8 +1446,7 @@ async fn loads_unquoted_short_description_containing_colon_space_and_apostrophe("name: colon-short-description\ndescription: long description\nmetadata:\n short-description: What's included: builds and tests",);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1828,8 +1478,7 @@ async fn loads_unrecognized_frontmatter_fields_that_need_quotes() {"name: repaired-unknown-fields\ndescription: valid description\nargument-hint: <duration: e.g. 7d, 2w>\ntags: [next,@supabase/ssr]",);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1861,8 +1510,7 @@ async fn preserves_block_scalar_body_while_repairing_other_fields() {"name: block-description-with-repair\ndescription: |-\n Build for AWS: ECS\nargument-hint: <duration: e.g. 7d>",);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1896,8 +1544,7 @@ async fn preserves_overlong_short_descriptions() {);fs::write(skill_dir.join(SKILLS_FILENAME), contents).unwrap();- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1923,8 +1570,7 @@ async fn skips_hidden_and_invalid() {fs::create_dir_all(&invalid_dir).unwrap();fs::write(invalid_dir.join(SKILLS_FILENAME), "---\nname: bad").unwrap();- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert_eq!(outcome.skills.len(), 0);assert_eq!(outcome.errors.len(), 1);assert!(@@ -1940,9 +1586,8 @@ async fn preserves_overlong_descriptions() {let codex_home = tempfile::tempdir().expect("tempdir");let max_desc = "\u{1F4A1}".repeat(MAX_DESCRIPTION_LEN);write_skill(&codex_home, "max-len", "max-len", &max_desc);- let cfg = make_config(&codex_home).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1952,7 +1597,7 @@ async fn preserves_overlong_descriptions() {let too_long_desc = "\u{1F4A1}".repeat(MAX_DESCRIPTION_LEN + 1);write_skill(&codex_home, "too-long", "too-long", &too_long_desc);- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_user_skills_for_test(&codex_home).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -1968,19 +1613,16 @@ async fn preserves_overlong_descriptions() {}#[tokio::test]-async fn loads_skills_from_repo_root() {- let codex_home = tempfile::tempdir().expect("tempdir");+async fn loads_skills_from_repo_scoped_root() {let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());let skills_root = repo_dir.path().join(REPO_ROOT_CONFIG_DIR_NAME).join(SKILLS_DIR_NAME);let skill_path = write_skill_at(&skills_root, "repo", "repo-skill", "from repo");- let cfg = make_config_for_cwd(&codex_home, repo_dir.path().to_path_buf()).await;- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_skills_for_test([local_skill_root(&skills_root, SkillScope::Repo)]).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -2002,76 +1644,28 @@ async fn loads_skills_from_repo_root() {}]);}-#[tokio::test]-async fn loads_skills_from_agents_dir_without_codex_dir() {- let codex_home = tempfile::tempdir().expect("tempdir");+async fn loads_skills_from_multiple_repo_scoped_roots() {let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());-- let skill_path = write_skill_at(- &repo_dir.path().join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME),- "agents",- "agents-skill",- "from agents",- );- let cfg = make_config_for_cwd(&codex_home, repo_dir.path().to_path_buf()).await;-- let outcome = load_skills_for_test(&cfg).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "agents-skill".to_string(),- description: "from agents".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- }]- );-}-#[tokio::test]-async fn loads_skills_from_all_codex_dirs_under_project_root() {- let codex_home = tempfile::tempdir().expect("tempdir");- let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());-- let nested_dir = repo_dir.path().join("nested/inner");- fs::create_dir_all(&nested_dir).unwrap();-- let root_skill_path = write_skill_at(- &repo_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "root",- "root-skill",- "from root",- );- let nested_skill_path = write_skill_at(- &repo_dir- .path()- .join("nested")- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "nested",- "nested-skill",- "from nested",- );-- let cfg = make_config_for_cwd(&codex_home, nested_dir).await;-- let outcome = load_skills_for_test(&cfg).await;+ let root_skills_root = repo_dir+ .path()+ .join(REPO_ROOT_CONFIG_DIR_NAME)+ .join(SKILLS_DIR_NAME);+ let nested_skills_root = repo_dir+ .path()+ .join("nested")+ .join(REPO_ROOT_CONFIG_DIR_NAME)+ .join(SKILLS_DIR_NAME);+ let root_skill_path = write_skill_at(&root_skills_root, "root", "root-skill", "from root");+ let nested_skill_path =+ write_skill_at(&nested_skills_root, "nested", "nested-skill", "from nested");++ let outcome = load_skills_for_test([+ local_skill_root(&nested_skills_root, SkillScope::Repo),+ local_skill_root(&root_skills_root, SkillScope::Repo),+ ])+ .await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -2107,117 +1701,6 @@ async fn loads_skills_from_all_codex_dirs_under_project_root() {]);}--#[tokio::test]-async fn repo_skill_root_search_limits_concurrent_probes_and_preserves_order() {- const CONCURRENCY_LIMIT: usize = 256;-- let codex_home = tempfile::tempdir().expect("tempdir");- let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());-- let mut directories = vec![repo_dir.path().to_path_buf()];- let mut cwd = repo_dir.path().to_path_buf();- for _ in 0..CONCURRENCY_LIMIT {- cwd.push("d");- directories.push(cwd.clone());- }- fs::create_dir_all(&cwd).expect("nested cwd");-- let expected_roots = [0, CONCURRENCY_LIMIT / 2, CONCURRENCY_LIMIT]- .map(|index| {- directories[index]- .join(AGENTS_DIR_NAME)- .join(SKILLS_DIR_NAME)- })- .map(|path| {- fs::create_dir_all(&path).expect("repo skill root");- path.abs()- });- let expected_probes = directories- .iter()- .map(|directory| {- PathUri::from_abs_path(&directory.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME).abs())- })- .collect::<Vec<_>>();- let cfg = make_config_for_cwd(&codex_home, cwd).await;- let metadata_calls = Arc::new(BlockingMetadataCalls::default());- let fs: Arc<dyn ExecutorFileSystem> = Arc::new(BlockingRepoSkillRootFileSystem {- inner: Arc::clone(&LOCAL_FS),- metadata_calls: Arc::clone(&metadata_calls),- blocked_walk_root: None,- blocked_walk_gate: Semaphore::new(/*permits*/ 0),- walks_started: AtomicUsize::new(/*v*/ 0),- walk_started: Notify::new(),- });-- let assertions = async {- tokio::time::timeout(std::time::Duration::from_secs(5), async {- loop {- let started = metadata_calls.started.notified();- if metadata_calls- .paths- .lock()- .expect("metadata paths lock")- .len()- >= CONCURRENCY_LIMIT- {- break;- }- started.await;- }- })- .await- .expect("initial repo skill root window should start");- assert_eq!(- metadata_calls- .paths- .lock()- .expect("metadata paths lock")- .as_slice(),- &expected_probes[..CONCURRENCY_LIMIT]- );-- metadata_calls.release.add_permits(1);- tokio::time::timeout(std::time::Duration::from_secs(5), async {- loop {- let started = metadata_calls.started.notified();- if metadata_calls- .paths- .lock()- .expect("metadata paths lock")- .len()- > CONCURRENCY_LIMIT- {- break;- }- started.await;- }- })- .await- .expect("next repo skill root probe should start");- assert_eq!(- metadata_calls- .paths- .lock()- .expect("metadata paths lock")- .as_slice(),- expected_probes.as_slice()- );-- metadata_calls.release.add_permits(expected_probes.len());- };- let (roots, ()) = tokio::join!(- super::repo_agents_skill_roots(Some(fs), &cfg.config_layer_stack, &cfg.cwd),- assertions- );-- assert_eq!(- roots.into_iter().map(|root| root.path).collect::<Vec<_>>(),- expected_roots- );-}-#[tokio::test]async fn merges_root_results_in_input_order_when_scans_finish_out_of_order() {const ROOT_COUNT: usize = MAX_CONCURRENT_ROOT_SCANS + 1;@@ -2242,7 +1725,6 @@ async fn merges_root_results_in_input_order_when_scans_finish_out_of_order() {let blocked_walk_root = PathUri::from_abs_path(&roots[0].abs());let file_system = Arc::new(BlockingRepoSkillRootFileSystem {inner: Arc::clone(&LOCAL_FS),- metadata_calls: Arc::new(BlockingMetadataCalls::default()),blocked_walk_root: Some(blocked_walk_root),blocked_walk_gate: Semaphore::new(/*permits*/ 0),walks_started: AtomicUsize::new(/*v*/ 0),@@ -2344,46 +1826,6 @@ async fn skill_root_scans_wait_for_shared_capacity() {assert_eq!(outcome.errors, Vec::new());}-#[tokio::test]-async fn loads_skills_from_codex_dir_when_not_git_repo() {- let codex_home = tempfile::tempdir().expect("tempdir");- let work_dir = tempfile::tempdir().expect("tempdir");-- let skill_path = write_skill_at(- &work_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "local",- "local-skill",- "from cwd",- );-- let cfg = make_config_for_cwd(&codex_home, work_dir.path().to_path_buf()).await;-- let outcome = load_skills_for_test(&cfg).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "local-skill".to_string(),- description: "from cwd".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- }]- );-}-#[tokio::test]async fn deduplicates_by_path_preferring_first_root() {let root = tempfile::tempdir().expect("tempdir");@@ -2442,22 +1884,19 @@ async fn deduplicates_by_path_preferring_first_root() {async fn keeps_duplicate_names_from_repo_and_user() {let codex_home = tempfile::tempdir().expect("tempdir");let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());let user_skill_path = write_skill(&codex_home, "user", "dupe-skill", "from user");- let repo_skill_path = write_skill_at(- &repo_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "repo",- "dupe-skill",- "from repo",- );-- let cfg = make_config_for_cwd(&codex_home, repo_dir.path().to_path_buf()).await;+ let repo_skills_root = repo_dir+ .path()+ .join(REPO_ROOT_CONFIG_DIR_NAME)+ .join(SKILLS_DIR_NAME);+ let repo_skill_path = write_skill_at(&repo_skills_root, "repo", "dupe-skill", "from repo");- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_skills_for_test([+ local_skill_root(&repo_skills_root, SkillScope::Repo),+ local_skill_root(&codex_home.path().join(SKILLS_DIR_NAME), SkillScope::User),+ ])+ .await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -2496,35 +1935,26 @@ async fn keeps_duplicate_names_from_repo_and_user() {#[tokio::test]async fn keeps_duplicate_names_from_nested_codex_dirs() {- let codex_home = tempfile::tempdir().expect("tempdir");let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());-- let nested_dir = repo_dir.path().join("nested/inner");- fs::create_dir_all(&nested_dir).unwrap();-- let root_skill_path = write_skill_at(- &repo_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "root",- "dupe-skill",- "from root",- );- let nested_skill_path = write_skill_at(- &repo_dir- .path()- .join("nested")- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "nested",- "dupe-skill",- "from nested",- );-- let cfg = make_config_for_cwd(&codex_home, nested_dir).await;- let outcome = load_skills_for_test(&cfg).await;++ let root_skills_root = repo_dir+ .path()+ .join(REPO_ROOT_CONFIG_DIR_NAME)+ .join(SKILLS_DIR_NAME);+ let nested_skills_root = repo_dir+ .path()+ .join("nested")+ .join(REPO_ROOT_CONFIG_DIR_NAME)+ .join(SKILLS_DIR_NAME);+ let root_skill_path = write_skill_at(&root_skills_root, "root", "dupe-skill", "from root");+ let nested_skill_path =+ write_skill_at(&nested_skills_root, "nested", "dupe-skill", "from nested");++ let outcome = load_skills_for_test([+ local_skill_root(&nested_skills_root, SkillScope::Repo),+ local_skill_root(&root_skills_root, SkillScope::Repo),+ ])+ .await;assert!(outcome.errors.is_empty(),@@ -2569,117 +1999,14 @@ async fn keeps_duplicate_names_from_nested_codex_dirs() {]);}-#[tokio::test]-async fn repo_skills_search_does_not_escape_repo_root() {+async fn loads_skills_from_system_scoped_root() {let codex_home = tempfile::tempdir().expect("tempdir");- let outer_dir = tempfile::tempdir().expect("tempdir");- let repo_dir = outer_dir.path().join("repo");- fs::create_dir_all(&repo_dir).unwrap();-- let _skill_path = write_skill_at(- &outer_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "outer",- "outer-skill",- "from outer",- );- mark_as_git_repo(&repo_dir);-- let cfg = make_config_for_cwd(&codex_home, repo_dir).await;-- let outcome = load_skills_for_test(&cfg).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 0);-}--#[tokio::test]-async fn loads_skills_when_cwd_is_file_in_repo() {- let codex_home = tempfile::tempdir().expect("tempdir");- let repo_dir = tempfile::tempdir().expect("tempdir");- mark_as_git_repo(repo_dir.path());-- let skill_path = write_skill_at(- &repo_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "repo",- "repo-skill",- "from repo",- );- let file_path = repo_dir.path().join("some-file.txt");- fs::write(&file_path, "contents").unwrap();-- let cfg = make_config_for_cwd(&codex_home, file_path).await;-- let outcome = load_skills_for_test(&cfg).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "repo-skill".to_string(),- description: "from repo".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn non_git_repo_skills_search_does_not_walk_parents() {- let codex_home = tempfile::tempdir().expect("tempdir");- let outer_dir = tempfile::tempdir().expect("tempdir");- let nested_dir = outer_dir.path().join("nested/inner");- fs::create_dir_all(&nested_dir).unwrap();-- write_skill_at(- &outer_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME),- "outer",- "outer-skill",- "from outer",- );-- let cfg = make_config_for_cwd(&codex_home, nested_dir).await;-- let outcome = load_skills_for_test(&cfg).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 0);-}--#[tokio::test]-async fn loads_skills_from_system_cache_when_present() {- let codex_home = tempfile::tempdir().expect("tempdir");- let work_dir = tempfile::tempdir().expect("tempdir");let skill_path = write_system_skill(&codex_home, "system", "system-skill", "from system");+ let system_root = codex_home.path().join("skills/.system");- let cfg = make_config_for_cwd(&codex_home, work_dir.path().to_path_buf()).await;-- let outcome = load_skills_for_test(&cfg).await;+ let outcome = load_skills_for_test([local_skill_root(&system_root, SkillScope::System)]).await;assert!(outcome.errors.is_empty(),"unexpected errors: {:?}",@@ -2701,27 +2028,3 @@ async fn loads_skills_from_system_cache_when_present() {}]);}--#[tokio::test]-async fn skill_roots_include_admin_with_lowest_priority() {- let codex_home = tempfile::tempdir().expect("tempdir");- let cfg = make_config(&codex_home).await;-- let scopes: Vec<SkillScope> = super::skill_roots(- Some(Arc::clone(&LOCAL_FS)),- &cfg.config_layer_stack,- &cfg.cwd,- Vec::new(),- Vec::new(),- )- .await- .into_iter()- .map(|root| root.scope)- .collect();- let mut expected = vec![SkillScope::User, SkillScope::System];- if home_dir().is_some() {- expected.insert(1, SkillScope::User);- }- expected.push(SkillScope::Admin);- assert_eq!(scopes, expected);-}diff --git a/codex-rs/core-skills/src/system.rs b/codex-rs/core-skills/src/system.rsdeleted file mode 100644index 3031246190..0000000000--- a/codex-rs/core-skills/src/system.rs+++ /dev/null@@ -1 +0,0 @@-pub(crate) use codex_skills::system_cache_root_dir;diff --git a/codex-rs/core/src/skills.rs b/codex-rs/core/src/skills.rsindex fb53a1ea8b..c965b97f4c 100644--- a/codex-rs/core/src/skills.rs+++ b/codex-rs/core/src/skills.rs@@ -26,7 +26,6 @@ pub use codex_core_skills::injection::collect_explicit_skill_mentions;pub use codex_core_skills::loader;pub use codex_core_skills::model;pub use codex_core_skills::remote;-pub use codex_core_skills::system;pub use codex_skills::SkillMetadata;pub use codex_skills::SkillPolicy;pub use codex_skills_extension::HostSkillsLoadInput;diff --git a/codex-rs/ext/skills/Cargo.toml b/codex-rs/ext/skills/Cargo.tomlindex a79e1188fc..c1f09ccbbf 100644--- a/codex-rs/ext/skills/Cargo.toml+++ b/codex-rs/ext/skills/Cargo.toml@@ -26,12 +26,14 @@ codex-utils-absolute-path = { workspace = true }codex-utils-path-uri = { workspace = true }codex-utils-plugins = { workspace = true }codex-utils-string = { workspace = true }+dirs = { workspace = true }futures = { workspace = true }schemars = { workspace = true }serde = { workspace = true, features = ["derive"] }serde_json = { workspace = true }serde_yaml = { workspace = true }tokio = { workspace = true, features = ["sync", "time"] }+toml = { workspace = true }tracing = { workspace = true }url = { workspace = true }@@ -44,4 +46,3 @@ opentelemetry_sdk = { workspace = true }pretty_assertions = { workspace = true }tempfile = { workspace = true }tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }-toml = { workspace = true }diff --git a/codex-rs/ext/skills/src/host_roots.rs b/codex-rs/ext/skills/src/host_roots.rsnew file mode 100644index 0000000000..dfa4652c82--- /dev/null+++ b/codex-rs/ext/skills/src/host_roots.rs@@ -0,0 +1,302 @@+use std::collections::HashSet;+use std::io;+use std::sync::Arc;++use codex_config::ConfigLayerSource;+use codex_config::ConfigLayerStack;+use codex_config::default_project_root_markers;+use codex_config::merge_toml_values;+use codex_config::project_root_markers_from_config;+use codex_core_skills::loader::SkillRoot;+use codex_exec_server::ExecutorFileSystem;+use codex_exec_server::LOCAL_FS;+use codex_protocol::protocol::SkillScope;+use codex_skills::system_cache_root_dir;+use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_path_uri::PathUri;+use codex_utils_plugins::PluginSkillRoot;+use codex_utils_plugins::SkillDiscoveryMode;+use dirs::home_dir;+use futures::StreamExt;+use toml::Value as TomlValue;++use crate::loader::HostSkillRoot;++const AGENTS_DIR_NAME: &str = ".agents";+const SKILLS_DIR_NAME: &str = "skills";+const MAX_CONCURRENT_ANCESTOR_PROBES: usize = 256;++pub(crate) async fn resolve_skill_roots(+ repository_file_system: Option<Arc<dyn ExecutorFileSystem>>,+ config_layer_stack: &ConfigLayerStack,+ cwd: &AbsolutePathBuf,+ plugin_skill_roots: Vec<PluginSkillRoot>,+ extra_skill_roots: Vec<AbsolutePathBuf>,+) -> Vec<SkillRoot> {+ let home_dir =+ home_dir().and_then(|path| AbsolutePathBuf::from_absolute_path_checked(path).ok());+ resolve_skill_roots_with_home_dir(+ repository_file_system,+ config_layer_stack,+ cwd,+ home_dir.as_ref(),+ plugin_skill_roots,+ extra_skill_roots,+ )+ .await+}++async fn resolve_skill_roots_with_home_dir(+ repository_file_system: Option<Arc<dyn ExecutorFileSystem>>,+ config_layer_stack: &ConfigLayerStack,+ cwd: &AbsolutePathBuf,+ home_dir: Option<&AbsolutePathBuf>,+ plugin_skill_roots: Vec<PluginSkillRoot>,+ extra_skill_roots: Vec<AbsolutePathBuf>,+) -> Vec<SkillRoot> {+ let mut roots =+ roots_from_layer_stack(config_layer_stack, home_dir, repository_file_system.clone())+ .into_iter()+ .map(host_root_to_skill_root)+ .collect::<Vec<_>>();+ roots.extend(plugin_skill_roots.into_iter().map(|root| SkillRoot {+ path: root.path,+ scope: SkillScope::User,+ file_system: Arc::clone(&LOCAL_FS),+ plugin_identity: Some(root.plugin_identity),+ plugin_namespace: Some(root.plugin_namespace),+ plugin_root: Some(root.plugin_root),+ discovery_mode: root.discovery_mode,+ }));+ roots.extend(+ extra_skill_roots+ .into_iter()+ .map(|path| local_root(path, SkillScope::User))+ .map(host_root_to_skill_root),+ );+ roots.extend(+ repo_agents_skill_roots(repository_file_system, config_layer_stack, cwd)+ .await+ .into_iter()+ .map(host_root_to_skill_root),+ );+ dedupe_skill_roots_by_path(&mut roots);+ roots+}++fn roots_from_layer_stack(+ config_layer_stack: &ConfigLayerStack,+ home_dir: Option<&AbsolutePathBuf>,+ repository_file_system: Option<Arc<dyn ExecutorFileSystem>>,+) -> Vec<HostSkillRoot> {+ let mut roots = Vec::new();++ for layer in config_layer_stack.all_layers_high_to_low() {+ let Some(config_folder) = layer.config_folder() else {+ continue;+ };++ match &layer.name {+ ConfigLayerSource::Project { .. } => {+ if let Some(repository_file_system) = &repository_file_system {+ roots.push(HostSkillRoot {+ path: config_folder.join(SKILLS_DIR_NAME),+ scope: SkillScope::Repo,+ file_system: Arc::clone(repository_file_system),+ plugin_root: None,+ });+ }+ }+ ConfigLayerSource::User { .. } => {+ // Deprecated user skills location (`$CODEX_HOME/skills`), kept for backward+ // compatibility.+ roots.push(local_root(+ config_folder.join(SKILLS_DIR_NAME),+ SkillScope::User,+ ));++ if let Some(home_dir) = home_dir {+ roots.push(local_root(+ home_dir.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME),+ SkillScope::User,+ ));+ }++ roots.push(local_root(+ system_cache_root_dir(&config_folder),+ SkillScope::System,+ ));+ }+ ConfigLayerSource::System { .. } => {+ roots.push(local_root(+ config_folder.join(SKILLS_DIR_NAME),+ SkillScope::Admin,+ ));+ }+ ConfigLayerSource::Mdm { .. }+ | ConfigLayerSource::EnterpriseManaged { .. }+ | ConfigLayerSource::SessionFlags+ | ConfigLayerSource::LegacyManagedConfigTomlFromFile { .. }+ | ConfigLayerSource::LegacyManagedConfigTomlFromMdm => {}+ }+ }++ roots+}++fn local_root(path: AbsolutePathBuf, scope: SkillScope) -> HostSkillRoot {+ HostSkillRoot {+ path,+ scope,+ file_system: Arc::clone(&LOCAL_FS),+ plugin_root: None,+ }+}++fn host_root_to_skill_root(root: HostSkillRoot) -> SkillRoot {+ SkillRoot {+ path: root.path,+ scope: root.scope,+ file_system: root.file_system,+ plugin_identity: None,+ plugin_namespace: None,+ plugin_root: None,+ discovery_mode: SkillDiscoveryMode::Recursive,+ }+}++async fn repo_agents_skill_roots(+ repository_file_system: Option<Arc<dyn ExecutorFileSystem>>,+ config_layer_stack: &ConfigLayerStack,+ cwd: &AbsolutePathBuf,+) -> Vec<HostSkillRoot> {+ let Some(repository_file_system) = repository_file_system else {+ return Vec::new();+ };+ let project_root_markers = project_root_markers_from_stack(config_layer_stack);+ let project_root =+ find_project_root(repository_file_system.as_ref(), cwd, &project_root_markers).await;+ let directories = dirs_between_project_root_and_cwd(cwd, &project_root);+ let mut roots = Vec::new();+ let mut results = futures::stream::iter(directories)+ .map(|directory| {+ let repository_file_system = Arc::clone(&repository_file_system);+ async move {+ let agents_skills = directory.join(AGENTS_DIR_NAME).join(SKILLS_DIR_NAME);+ let agents_skills_uri = PathUri::from_abs_path(&agents_skills);+ let result = repository_file_system+ .get_metadata(&agents_skills_uri, /*sandbox*/ None)+ .await;+ (agents_skills, result)+ }+ })+ .buffered(MAX_CONCURRENT_ANCESTOR_PROBES);+ while let Some((agents_skills, result)) = results.next().await {+ match result {+ Ok(metadata) if metadata.is_directory => roots.push(HostSkillRoot {+ path: agents_skills,+ scope: SkillScope::Repo,+ file_system: Arc::clone(&repository_file_system),+ plugin_root: None,+ }),+ Ok(_) => {}+ Err(error) if error.kind() == io::ErrorKind::NotFound => {}+ Err(error) => {+ tracing::warn!(+ "failed to stat repo skills root {}: {error:#}",+ agents_skills.display()+ );+ }+ }+ }+ roots+}++fn project_root_markers_from_stack(config_layer_stack: &ConfigLayerStack) -> Vec<String> {+ let mut merged = TomlValue::Table(toml::map::Map::new());+ for layer in config_layer_stack.layers_low_to_high() {+ if matches!(layer.name, ConfigLayerSource::Project { .. }) {+ continue;+ }+ merge_toml_values(&mut merged, &layer.config);+ }++ match project_root_markers_from_config(&merged) {+ Ok(Some(markers)) => markers,+ Ok(None) => default_project_root_markers(),+ Err(error) => {+ tracing::warn!("invalid project_root_markers: {error}");+ default_project_root_markers()+ }+ }+}++async fn find_project_root(+ repository_file_system: &dyn ExecutorFileSystem,+ cwd: &AbsolutePathBuf,+ project_root_markers: &[String],+) -> AbsolutePathBuf {+ if project_root_markers.is_empty() {+ return cwd.clone();+ }++ let mut probes = Vec::new();+ for ancestor in cwd.ancestors() {+ for marker in project_root_markers {+ probes.push((ancestor.clone(), ancestor.join(marker)));+ }+ }+ let mut results = futures::stream::iter(probes)+ .map(|(ancestor, marker_path)| async move {+ let marker_path_uri = PathUri::from_abs_path(&marker_path);+ let result = repository_file_system+ .get_metadata(&marker_path_uri, /*sandbox*/ None)+ .await;+ (ancestor, marker_path, result)+ })+ .buffered(MAX_CONCURRENT_ANCESTOR_PROBES);+ while let Some((ancestor, marker_path, result)) = results.next().await {+ match result {+ Ok(_) => return ancestor,+ Err(error) if error.kind() == io::ErrorKind::NotFound => {}+ Err(error) => {+ tracing::warn!(+ "failed to stat project root marker {}: {error:#}",+ marker_path.display()+ );+ }+ }+ }++ cwd.clone()+}++fn dirs_between_project_root_and_cwd(+ cwd: &AbsolutePathBuf,+ project_root: &AbsolutePathBuf,+) -> Vec<AbsolutePathBuf> {+ let mut directories = cwd+ .ancestors()+ .scan(false, |done, directory| {+ if *done {+ None+ } else {+ if &directory == project_root {+ *done = true;+ }+ Some(directory)+ }+ })+ .collect::<Vec<_>>();+ directories.reverse();+ directories+}++fn dedupe_skill_roots_by_path(roots: &mut Vec<SkillRoot>) {+ let mut seen = HashSet::new();+ roots.retain(|root| seen.insert(root.path.clone()));+}++#[cfg(test)]+#[path = "host_roots_tests.rs"]+mod tests;diff --git a/codex-rs/ext/skills/src/host_roots_tests.rs b/codex-rs/ext/skills/src/host_roots_tests.rsnew file mode 100644index 0000000000..b31072ae69--- /dev/null+++ b/codex-rs/ext/skills/src/host_roots_tests.rs@@ -0,0 +1,668 @@+use std::fs;+use std::path::Path;+use std::sync::Arc;+use std::sync::Mutex;++use codex_config::ConfigLayerEntry;+use codex_config::ConfigLayerSource;+use codex_config::ConfigLayerStack;+use codex_config::ConfigRequirementsToml;+use codex_core_skills::SkillMetadata;+use codex_core_skills::loader::MAX_CONCURRENT_ROOT_SCANS;+use codex_core_skills::loader::load_skills_from_roots;+use codex_exec_server::CopyOptions;+use codex_exec_server::CreateDirectoryOptions;+use codex_exec_server::ExecutorFileSystem;+use codex_exec_server::ExecutorFileSystemFuture;+use codex_exec_server::FileMetadata;+use codex_exec_server::FileSystemReadStream;+use codex_exec_server::FileSystemSandboxContext;+use codex_exec_server::LOCAL_FS;+use codex_exec_server::ReadDirectoryEntry;+use codex_exec_server::RemoveOptions;+use codex_exec_server::WalkOptions;+use codex_exec_server::WalkOutcome;+use codex_protocol::protocol::SkillScope;+use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_path_uri::PathUri;+use codex_utils_plugins::PluginIdentity;+use codex_utils_plugins::PluginSkillRoot;+use codex_utils_plugins::SkillDiscoveryMode;+use pretty_assertions::assert_eq;+use tempfile::TempDir;+use tokio::sync::Notify;+use tokio::sync::Semaphore;++use super::repo_agents_skill_roots;+use super::resolve_skill_roots_with_home_dir;+use super::roots_from_layer_stack;++struct BlockingMetadataFileSystem {+ inner: Arc<dyn ExecutorFileSystem>,+ calls: Arc<BlockingMetadataCalls>,+}++struct BlockingMetadataCalls {+ paths: Mutex<Vec<PathUri>>,+ started: Notify,+ release: Semaphore,+}++impl Default for BlockingMetadataCalls {+ fn default() -> Self {+ Self {+ paths: Mutex::new(Vec::new()),+ started: Notify::new(),+ release: Semaphore::new(0),+ }+ }+}++impl ExecutorFileSystem for BlockingMetadataFileSystem {+ fn canonicalize<'a>(+ &'a self,+ path: &'a PathUri,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, PathUri> {+ self.inner.canonicalize(path, sandbox)+ }++ fn read_file<'a>(+ &'a self,+ path: &'a PathUri,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, Vec<u8>> {+ self.inner.read_file(path, sandbox)+ }++ fn read_file_stream<'a>(+ &'a self,+ path: &'a PathUri,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, FileSystemReadStream> {+ self.inner.read_file_stream(path, sandbox)+ }++ fn write_file<'a>(+ &'a self,+ path: &'a PathUri,+ contents: Vec<u8>,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, ()> {+ self.inner.write_file(path, contents, sandbox)+ }++ fn create_directory<'a>(+ &'a self,+ path: &'a PathUri,+ options: CreateDirectoryOptions,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, ()> {+ self.inner.create_directory(path, options, sandbox)+ }++ fn get_metadata<'a>(+ &'a self,+ path: &'a PathUri,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, FileMetadata> {+ let Ok(path_abs) = path.to_abs_path() else {+ return self.inner.get_metadata(path, sandbox);+ };+ let repo_skill_root_suffix = Path::new(".agents").join("skills");+ if !path_abs.ends_with(repo_skill_root_suffix) {+ return self.inner.get_metadata(path, sandbox);+ }++ self.calls+ .paths+ .lock()+ .expect("metadata paths lock")+ .push(path.clone());+ self.calls.started.notify_one();+ Box::pin(async move {+ self.calls+ .release+ .acquire()+ .await+ .expect("metadata release semaphore")+ .forget();+ self.inner.get_metadata(path, sandbox).await+ })+ }++ fn read_directory<'a>(+ &'a self,+ path: &'a PathUri,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, Vec<ReadDirectoryEntry>> {+ self.inner.read_directory(path, sandbox)+ }++ fn walk<'a>(+ &'a self,+ path: &'a PathUri,+ options: WalkOptions,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, WalkOutcome> {+ self.inner.walk(path, options, sandbox)+ }++ fn remove<'a>(+ &'a self,+ path: &'a PathUri,+ options: RemoveOptions,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, ()> {+ self.inner.remove(path, options, sandbox)+ }++ fn copy<'a>(+ &'a self,+ source_path: &'a PathUri,+ destination_path: &'a PathUri,+ options: CopyOptions,+ sandbox: Option<&'a FileSystemSandboxContext>,+ ) -> ExecutorFileSystemFuture<'a, ()> {+ self.inner+ .copy(source_path, destination_path, options, sandbox)+ }+}++fn absolute(path: impl Into<std::path::PathBuf>) -> AbsolutePathBuf {+ AbsolutePathBuf::try_from(path.into()).expect("absolute path")+}++fn empty_config() -> toml::Value {+ toml::Value::Table(toml::map::Map::new())+}++fn stack(layers: Vec<ConfigLayerEntry>) -> ConfigLayerStack {+ ConfigLayerStack::new(+ layers,+ Default::default(),+ ConfigRequirementsToml::default(),+ )+ .expect("valid config stack")+}++fn user_layer(codex_home: &AbsolutePathBuf) -> ConfigLayerEntry {+ ConfigLayerEntry::new(+ ConfigLayerSource::User {+ file: codex_home.join("config.toml"),+ profile: None,+ },+ empty_config(),+ )+}++fn project_layer(dot_codex_folder: &AbsolutePathBuf) -> ConfigLayerEntry {+ ConfigLayerEntry::new(+ ConfigLayerSource::Project {+ dot_codex_folder: dot_codex_folder.clone(),+ },+ empty_config(),+ )+}++fn write_skill(root: &AbsolutePathBuf, directory: &str, name: &str) -> AbsolutePathBuf {+ let skill_dir = root.join(directory);+ fs::create_dir_all(&skill_dir).expect("create skill directory");+ let skill_path = skill_dir.join("SKILL.md");+ fs::write(+ &skill_path,+ format!("---\nname: {name}\ndescription: {name} description\n---\n"),+ )+ .expect("write skill");+ AbsolutePathBuf::from_absolute_path(+ dunce::canonicalize(skill_path).expect("canonical skill path"),+ )+ .expect("absolute skill path")+}++fn expected_skill(path: AbsolutePathBuf, name: &str, scope: SkillScope) -> SkillMetadata {+ SkillMetadata {+ name: name.to_string(),+ description: format!("{name} description"),+ short_description: None,+ interface: None,+ dependencies: None,+ policy: None,+ path_to_skills_md: path,+ scope,+ plugin_id: None,+ remote_plugin_id: None,+ }+}++#[test]+fn layer_roots_preserve_scope_precedence_and_disabled_projects() {+ let temp_dir = TempDir::new().expect("temp dir");+ let system_folder = absolute(temp_dir.path().join("etc/codex"));+ let home_folder = absolute(temp_dir.path().join("home"));+ let user_folder = home_folder.join("codex");+ let project_folder = absolute(temp_dir.path().join("repo/.codex"));+ let nested_project_folder = absolute(temp_dir.path().join("repo/nested/.codex"));+ let config_stack = stack(vec![+ ConfigLayerEntry::new(+ ConfigLayerSource::System {+ file: system_folder.join("config.toml"),+ },+ empty_config(),+ ),+ user_layer(&user_folder),+ ConfigLayerEntry::new_disabled(+ ConfigLayerSource::Project {+ dot_codex_folder: project_folder.clone(),+ },+ empty_config(),+ "untrusted project",+ ),+ project_layer(&nested_project_folder),+ ]);++ let roots = roots_from_layer_stack(+ &config_stack,+ Some(&home_folder),+ Some(Arc::clone(&LOCAL_FS)),+ )+ .into_iter()+ .map(|root| (root.scope, root.path))+ .collect::<Vec<_>>();++ assert_eq!(+ roots,+ vec![+ (SkillScope::Repo, nested_project_folder.join("skills")),+ (SkillScope::Repo, project_folder.join("skills")),+ (SkillScope::User, user_folder.join("skills")),+ (SkillScope::User, home_folder.join(".agents/skills")),+ (SkillScope::System, user_folder.join("skills/.system")),+ (SkillScope::Admin, system_folder.join("skills")),+ ]+ );+}++#[tokio::test]+async fn plugin_roots_preserve_plugin_resolution_metadata() {+ let temp_dir = TempDir::new().expect("temp dir");+ let cwd = absolute(temp_dir.path().join("workspace"));+ let plugin_root = absolute(temp_dir.path().join("plugins/example"));+ let skills_root = plugin_root.join("skills");+ let plugin_identity = PluginIdentity {+ plugin_id: "example@test".to_string(),+ remote_plugin_id: Some("plugins~Plugin_example".to_string()),+ };+ let plugin_namespace = "example".to_string();++ let roots = resolve_skill_roots_with_home_dir(+ /*repository_file_system*/ None,+ &stack(Vec::new()),+ &cwd,+ /*home_dir*/ None,+ vec![PluginSkillRoot {+ path: skills_root.clone(),+ plugin_identity: plugin_identity.clone(),+ plugin_namespace: plugin_namespace.clone(),+ plugin_root: plugin_root.clone(),+ discovery_mode: SkillDiscoveryMode::DirectChildren,+ }],+ Vec::new(),+ )+ .await;++ assert_eq!(roots.len(), 1);+ let root = &roots[0];+ assert_eq!(+ (+ root.path.clone(),+ root.scope,+ root.plugin_identity.clone(),+ root.plugin_namespace.clone(),+ root.plugin_root.clone(),+ root.discovery_mode,+ ),+ (+ skills_root,+ SkillScope::User,+ Some(plugin_identity),+ Some(plugin_namespace),+ Some(plugin_root),+ SkillDiscoveryMode::DirectChildren,+ )+ );+ assert!(Arc::ptr_eq(&root.file_system, &LOCAL_FS));+}++#[tokio::test]+async fn unique_extra_root_loads_as_recursive_user_root() {+ let temp_dir = TempDir::new().expect("temp dir");+ let cwd = absolute(temp_dir.path().join("workspace"));+ let extra_root = absolute(temp_dir.path().join("runtime-skills"));+ let skill_path = write_skill(&extra_root, "runtime", "runtime-skill");++ let roots = resolve_skill_roots_with_home_dir(+ /*repository_file_system*/ None,+ &stack(Vec::new()),+ &cwd,+ /*home_dir*/ None,+ Vec::new(),+ vec![extra_root.clone()],+ )+ .await;++ assert_eq!(roots.len(), 1);+ let root = &roots[0];+ assert_eq!(+ (+ root.path.clone(),+ root.scope,+ root.plugin_identity.clone(),+ root.plugin_namespace.clone(),+ root.plugin_root.clone(),+ root.discovery_mode,+ ),+ (+ extra_root,+ SkillScope::User,+ None,+ None,+ None,+ SkillDiscoveryMode::Recursive,+ )+ );+ assert!(Arc::ptr_eq(&root.file_system, &LOCAL_FS));++ let outcome = load_skills_from_roots(+ roots,+ /*plugin_skill_snapshots*/ None,+ Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),+ )+ .await;++ assert!(outcome.errors.is_empty());+ assert_eq!(+ outcome.skills,+ vec![expected_skill(+ skill_path,+ "runtime-skill",+ SkillScope::User,+ )]+ );+}++#[tokio::test]+async fn repo_ancestry_without_project_marker_does_not_walk_parents() {+ let temp_dir = TempDir::new().expect("temp dir");+ let outer = absolute(temp_dir.path().join("outer"));+ let cwd = outer.join("nested/inner");+ fs::create_dir_all(outer.join(".agents/skills")).expect("create outer skills");+ fs::create_dir_all(cwd.join(".agents/skills")).expect("create cwd skills");++ let roots = repo_agents_skill_roots(Some(Arc::clone(&LOCAL_FS)), &stack(Vec::new()), &cwd)+ .await+ .into_iter()+ .map(|root| root.path)+ .collect::<Vec<_>>();++ assert_eq!(roots, vec![cwd.join(".agents/skills")]);+}++#[tokio::test]+async fn repo_ancestry_stops_at_project_root_and_preserves_root_to_cwd_order() {+ let temp_dir = TempDir::new().expect("temp dir");+ let outer = absolute(temp_dir.path().join("outer"));+ let repository = outer.join("repo");+ let nested = repository.join("nested/inner");+ fs::create_dir_all(&nested).expect("create nested cwd");+ fs::write(repository.join(".git"), "gitdir: fake\n").expect("write git marker");+ fs::create_dir_all(outer.join(".agents/skills")).expect("create outer skills");+ fs::create_dir_all(repository.join(".agents/skills")).expect("create repo skills");+ fs::create_dir_all(repository.join("nested/.agents/skills")).expect("create nested skills");+ let config_stack = stack(Vec::new());++ let roots = repo_agents_skill_roots(Some(Arc::clone(&LOCAL_FS)), &config_stack, &nested)+ .await+ .into_iter()+ .map(|root| root.path)+ .collect::<Vec<_>>();++ assert_eq!(+ roots,+ vec![+ repository.join(".agents/skills"),+ repository.join("nested/.agents/skills"),+ ]+ );+}++#[tokio::test]+async fn resolved_project_layer_loads_skill_without_git_marker() {+ let temp_dir = TempDir::new().expect("temp dir");+ let workspace = absolute(temp_dir.path().join("workspace"));+ let dot_codex = workspace.join(".codex");+ let skill_root = dot_codex.join("skills");+ fs::create_dir_all(&workspace).expect("create workspace");+ let skill_path = write_skill(&skill_root, "local", "local-skill");+ let config_stack = stack(vec![project_layer(&dot_codex)]);++ let roots = resolve_skill_roots_with_home_dir(+ Some(Arc::clone(&LOCAL_FS)),+ &config_stack,+ &workspace,+ /*home_dir*/ None,+ Vec::new(),+ Vec::new(),+ )+ .await;+ let outcome = load_skills_from_roots(+ roots,+ /*plugin_skill_snapshots*/ None,+ Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),+ )+ .await;++ assert!(outcome.errors.is_empty());+ assert_eq!(+ outcome.skills,+ vec![expected_skill(skill_path, "local-skill", SkillScope::Repo)]+ );+}++#[tokio::test]+async fn resolved_project_layer_loads_skill_when_cwd_is_file() {+ let temp_dir = TempDir::new().expect("temp dir");+ let repository = absolute(temp_dir.path().join("repo"));+ let dot_codex = repository.join(".codex");+ let skill_root = dot_codex.join("skills");+ fs::create_dir_all(&repository).expect("create repository");+ fs::write(repository.join(".git"), "gitdir: fake\n").expect("write git marker");+ let cwd = repository.join("some-file.txt");+ fs::write(&cwd, "contents").expect("write cwd file");+ let skill_path = write_skill(&skill_root, "repo", "repo-skill");+ let config_stack = stack(vec![project_layer(&dot_codex)]);++ let roots = resolve_skill_roots_with_home_dir(+ Some(Arc::clone(&LOCAL_FS)),+ &config_stack,+ &cwd,+ /*home_dir*/ None,+ Vec::new(),+ Vec::new(),+ )+ .await;+ let outcome = load_skills_from_roots(+ roots,+ /*plugin_skill_snapshots*/ None,+ Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),+ )+ .await;++ assert!(outcome.errors.is_empty());+ assert_eq!(+ outcome.skills,+ vec![expected_skill(skill_path, "repo-skill", SkillScope::Repo)]+ );+}++#[tokio::test]+async fn repo_ancestry_limits_concurrent_probes_and_preserves_order() {+ const CONCURRENCY_LIMIT: usize = 256;++ let temp_dir = TempDir::new().expect("temp dir");+ let repository = absolute(temp_dir.path().join("repo"));+ fs::create_dir_all(&repository).expect("create repository");+ fs::write(repository.join(".git"), "gitdir: fake\n").expect("write git marker");++ let mut directories = vec![repository.clone()];+ let mut cwd = repository;+ for _ in 0..CONCURRENCY_LIMIT {+ cwd = cwd.join("d");+ directories.push(cwd.clone());+ }+ fs::create_dir_all(&cwd).expect("create nested cwd");++ let expected_roots = [0, CONCURRENCY_LIMIT / 2, CONCURRENCY_LIMIT].map(|index| {+ let path = directories[index].join(".agents/skills");+ fs::create_dir_all(&path).expect("create repo skill root");+ path+ });+ let expected_probes = directories+ .iter()+ .map(|directory| PathUri::from_abs_path(&directory.join(".agents/skills")))+ .collect::<Vec<_>>();+ let calls = Arc::new(BlockingMetadataCalls::default());+ let file_system: Arc<dyn ExecutorFileSystem> = Arc::new(BlockingMetadataFileSystem {+ inner: Arc::clone(&LOCAL_FS),+ calls: Arc::clone(&calls),+ });++ let assertions = async {+ tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), async {+ loop {+ let started = calls.started.notified();+ if calls.paths.lock().expect("metadata paths lock").len() >= CONCURRENCY_LIMIT {+ break;+ }+ started.await;+ }+ })+ .await+ .expect("initial repo skill root window should start");+ assert_eq!(+ calls.paths.lock().expect("metadata paths lock").as_slice(),+ &expected_probes[..CONCURRENCY_LIMIT]+ );++ calls.release.add_permits(/*n*/ 1);+ tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), async {+ loop {+ let started = calls.started.notified();+ if calls.paths.lock().expect("metadata paths lock").len() > CONCURRENCY_LIMIT {+ break;+ }+ started.await;+ }+ })+ .await+ .expect("next repo skill root probe should start");+ assert_eq!(+ calls.paths.lock().expect("metadata paths lock").as_slice(),+ expected_probes.as_slice()+ );++ calls.release.add_permits(expected_probes.len());+ };+ let config_stack = stack(Vec::new());+ let (roots, ()) = tokio::join!(+ repo_agents_skill_roots(Some(file_system), &config_stack, &cwd),+ assertions,+ );++ assert_eq!(+ roots.into_iter().map(|root| root.path).collect::<Vec<_>>(),+ expected_roots+ );+}++#[tokio::test]+async fn resolved_config_and_repo_roots_preserve_order_and_dedupe_paths_not_names() {+ let temp_dir = TempDir::new().expect("temp dir");+ let home_folder = absolute(temp_dir.path().join("home"));+ let codex_home = home_folder.join("codex");+ let system_folder = absolute(temp_dir.path().join("etc/codex"));+ let repository = absolute(temp_dir.path().join("repo"));+ let cwd = repository.join("nested/inner");+ fs::create_dir_all(&cwd).expect("create cwd");+ fs::write(repository.join(".git"), "gitdir: fake\n").expect("write git marker");++ let project_dot_codex = repository.join(".codex");+ let nested_project_dot_codex = repository.join("nested/.codex");+ let user_skills = codex_home.join("skills");+ let root_project_skill = write_skill(+ &project_dot_codex.join("skills"),+ "root-duplicate",+ "duplicate-skill",+ );+ let nested_project_skill = write_skill(+ &nested_project_dot_codex.join("skills"),+ "nested-duplicate",+ "duplicate-skill",+ );+ let user_skill = write_skill(&user_skills, "user-duplicate", "duplicate-skill");+ let home_skill = write_skill(&home_folder.join(".agents/skills"), "home", "home-skill");+ let system_skill = write_skill(&codex_home.join("skills/.system"), "system", "system-skill");+ let admin_skill = write_skill(&system_folder.join("skills"), "admin", "admin-skill");+ let repo_agent_skill = write_skill(+ &repository.join(".agents/skills"),+ "repo-agent",+ "repo-agent-skill",+ );+ let nested_agent_skill = write_skill(+ &repository.join("nested/.agents/skills"),+ "nested-agent",+ "nested-agent-skill",+ );+ let config_stack = stack(vec![+ ConfigLayerEntry::new(+ ConfigLayerSource::System {+ file: system_folder.join("config.toml"),+ },+ empty_config(),+ ),+ user_layer(&codex_home),+ project_layer(&project_dot_codex),+ project_layer(&nested_project_dot_codex),+ ]);++ let roots = resolve_skill_roots_with_home_dir(+ Some(Arc::clone(&LOCAL_FS)),+ &config_stack,+ &cwd,+ Some(&home_folder),+ Vec::new(),+ vec![user_skills],+ )+ .await;+ assert_eq!(roots.len(), 8);+ let outcome = load_skills_from_roots(+ roots,+ /*plugin_skill_snapshots*/ None,+ Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),+ )+ .await;+ assert!(outcome.errors.is_empty());+ assert_eq!(+ outcome.skills,+ vec![+ expected_skill(root_project_skill, "duplicate-skill", SkillScope::Repo),+ expected_skill(nested_project_skill, "duplicate-skill", SkillScope::Repo),+ expected_skill(nested_agent_skill, "nested-agent-skill", SkillScope::Repo),+ expected_skill(repo_agent_skill, "repo-agent-skill", SkillScope::Repo),+ expected_skill(user_skill, "duplicate-skill", SkillScope::User),+ expected_skill(home_skill, "home-skill", SkillScope::User),+ expected_skill(system_skill, "system-skill", SkillScope::System),+ expected_skill(admin_skill, "admin-skill", SkillScope::Admin),+ ]+ );+}diff --git a/codex-rs/ext/skills/src/host_service.rs b/codex-rs/ext/skills/src/host_service.rsindex 6edb174d2a..8bc487eaaa 100644--- a/codex-rs/ext/skills/src/host_service.rs+++ b/codex-rs/ext/skills/src/host_service.rs@@ -24,10 +24,11 @@ use codex_core_skills::config_rules::skill_config_rules_from_stack;use codex_core_skills::loader::MAX_CONCURRENT_ROOT_SCANS;use codex_core_skills::loader::SkillRoot;use codex_core_skills::loader::load_skills_from_roots;-use codex_core_skills::loader::skill_roots;use codex_skills::install_system_skills;use codex_skills::system_cache_root_dir;+use crate::host_roots::resolve_skill_roots;+#[derive(Debug, Clone)]pub struct HostSkillsLoadInput {pub cwd: AbsolutePathBuf,@@ -156,7 +157,7 @@ impl HostSkillsService {input: &HostSkillsLoadInput,fs: Option<Arc<dyn ExecutorFileSystem>>,) -> Vec<SkillRoot> {- let mut roots = skill_roots(+ let mut roots = resolve_skill_roots(fs,&input.config_layer_stack,&input.cwd,@@ -184,7 +185,7 @@ impl HostSkillsService {return snapshot;}- let mut roots = skill_roots(+ let mut roots = resolve_skill_roots(fs.clone(),&input.config_layer_stack,&input.cwd,diff --git a/codex-rs/ext/skills/src/lib.rs b/codex-rs/ext/skills/src/lib.rsindex 2901d2b1a7..df740b4f9b 100644--- a/codex-rs/ext/skills/src/lib.rs+++ b/codex-rs/ext/skills/src/lib.rs@@ -4,6 +4,7 @@ mod config;mod dynamic_skill_selector;mod extension;mod fragments;+mod host_roots;mod host_service;// Host loading is staged before its crate-internal runtime caller in this PR stack.#[allow(dead_code)]diff --git a/codex-rs/ext/skills/src/loader/mod.rs b/codex-rs/ext/skills/src/loader/mod.rsindex 148fbffd96..aa8fb07adb 100644--- a/codex-rs/ext/skills/src/loader/mod.rs+++ b/codex-rs/ext/skills/src/loader/mod.rs@@ -6,6 +6,7 @@ mod namespace;pub(crate) use environment::load_environment_skills_from_discovery;pub(crate) use environment::load_environment_skills_from_root;+pub(crate) use host::HostSkillRoot;pub(super) const SKILLS_FILENAME: &str = "SKILL.md";pub(super) const SKILLS_METADATA_DIR: &str = "agents";