Lightweight coding agent that runs in your terminal
Rust
Remove the legacy core skill loader (#37457)
felixxia-oai33e365b19e4a
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 3d8580a22e..8e4fda1034 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2919,18 +2919,13 @@ dependencies = ["codex-login","codex-model-provider","codex-otel",- "codex-protocol","codex-skills","codex-utils-absolute-path","codex-utils-path-uri",- "codex-utils-plugins","codex-utils-string",- "dunce",- "futures","pretty_assertions","serde","serde_json",- "serde_yaml","tempfile","tokio","toml 0.9.11+spec-1.1.0",diff --git a/codex-rs/app-server/src/skills_watcher.rs b/codex-rs/app-server/src/skills_watcher.rsindex 49a83297ab..e09358b6f2 100644--- a/codex-rs/app-server/src/skills_watcher.rs+++ b/codex-rs/app-server/src/skills_watcher.rs@@ -126,7 +126,7 @@ impl SkillsWatcher {.into_iter()// Plugin roots have explicit lifecycle invalidation; generated system skills are// installed before this watcher starts.- .filter(|root| root.plugin_identity.is_none() && root.scope != SkillScope::System)+ .filter(|root| root.plugin_identity().is_none() && root.scope != SkillScope::System).map(|root| WatchPath {path: root.path.into_path_buf(),recursive: true,diff --git a/codex-rs/core-plugins/src/tool_suggest_metadata.rs b/codex-rs/core-plugins/src/tool_suggest_metadata.rsindex 91bdcdb365..28671050a5 100644--- a/codex-rs/core-plugins/src/tool_suggest_metadata.rs+++ b/codex-rs/core-plugins/src/tool_suggest_metadata.rs@@ -20,7 +20,7 @@ use crate::app_mcp_routing::apply_app_mcp_routing_policy;use crate::loader::PluginSkillInventory;use crate::loader::load_plugin_apps;use crate::loader::load_plugin_mcp_servers;-use crate::loader::load_plugin_skill_inventory_with_loader;+use crate::loader::load_plugin_skill_inventory;use crate::manager::ConfiguredMarketplacePlugin;use crate::manager::remote_plugin_install_required_description;use crate::manifest::PluginManifestFormat;@@ -230,7 +230,7 @@ async fn load_plugin_metadata(remote_plugin_id: None,};let manifest = loaded_manifest.manifest;- let skill_inventory = load_plugin_skill_inventory_with_loader(+ let skill_inventory = load_plugin_skill_inventory(plugin_root,&plugin_identity,&manifest,diff --git a/codex-rs/core-skills/Cargo.toml b/codex-rs/core-skills/Cargo.tomlindex 43d054cbf7..c0d27559aa 100644--- a/codex-rs/core-skills/Cargo.toml+++ b/codex-rs/core-skills/Cargo.toml@@ -21,17 +21,12 @@ codex-exec-server = { workspace = true }codex-login = { workspace = true }codex-model-provider = { workspace = true }codex-otel = { workspace = true }-codex-protocol = { workspace = true }codex-skills = { workspace = true }codex-utils-absolute-path = { workspace = true }codex-utils-path-uri = { workspace = true }-codex-utils-plugins = { workspace = true }codex-utils-string = { workspace = true }-dunce = { workspace = true }-futures = { workspace = true }serde = { workspace = true, features = ["derive"] }serde_json = { workspace = true }-serde_yaml = { workspace = true }tokio = { workspace = true, features = ["fs", "macros", "rt"] }tracing = { workspace = true }zip = { workspace = true }diff --git a/codex-rs/core-skills/src/lib.rs b/codex-rs/core-skills/src/lib.rsindex 5e45368241..f7e5ad130a 100644--- a/codex-rs/core-skills/src/lib.rs+++ b/codex-rs/core-skills/src/lib.rs@@ -1,10 +1,8 @@pub mod config_rules;pub mod injection;pub(crate) mod invocation_utils;-pub mod loader;pub mod model;pub mod remote;-mod root_loader;mod skill_instructions;/// Hard byte limit for one model-visible skill instruction body.@@ -21,6 +19,4 @@ pub use model::SkillError;pub use model::SkillLoadOutcome;pub use model::SkillMetadata;pub use model::SkillPolicy;-pub use model::filter_skill_load_outcome_for_product;-pub use root_loader::PluginSkillSnapshots;pub use skill_instructions::SkillInstructions;diff --git a/codex-rs/core-skills/src/loader.rs b/codex-rs/core-skills/src/loader.rsdeleted file mode 100644index 2a84238358..0000000000--- a/codex-rs/core-skills/src/loader.rs+++ /dev/null@@ -1,645 +0,0 @@-mod discovery;-mod environment;-mod namespace;--pub use crate::root_loader::load_skill_root_snapshot;-pub use environment::EnvironmentSkillLoadOutcome;-pub use environment::EnvironmentSkillMetadata;-pub use environment::load_environment_skills_from_root;--use crate::model::SkillDependencies;-use crate::model::SkillError;-use crate::model::SkillInterface;-use crate::model::SkillLoadOutcome;-use crate::model::SkillMetadata;-use crate::model::SkillPolicy;-use crate::model::SkillToolDependency;-use codex_exec_server::ExecutorFileSystem;-use codex_protocol::protocol::Product;-use codex_protocol::protocol::SkillScope;-use codex_skills::ParsedSkillFrontmatter;-use codex_skills::SkillInterfaceAssetPolicy;-use codex_skills::SkillInterfaceFile;-use codex_skills::SkillParseError;-use codex_skills::parse_skill_frontmatter_metadata;-use codex_skills::resolve_skill_interface;-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::SkillDiscoveryMode;-use discovery::DirectorySymlinkPolicy;-use discovery::DiscoveredSkill;-use discovery::HiddenDirectoryPolicy;-use discovery::MAX_CONCURRENT_SKILL_LOADS;-use discovery::SkillDiscovery;-use discovery::SkillDiscoveryOptions;-use discovery::SkillMetadataDiscovery;-use discovery::discover_skills;-use futures::FutureExt;-use futures::StreamExt;-use namespace::SkillNamespaceResolver;-use serde::Deserialize;-use std::collections::HashMap;-use std::error::Error;-use std::fmt;-use std::io;-use std::sync::Arc;-use tokio::sync::Semaphore;-use tracing::error;--// TODO(anp): Tune this eight-scan limit after revisiting byte-based backpressure.-pub const MAX_CONCURRENT_ROOT_SCANS: usize = 8;--#[derive(Debug, Default, Deserialize)]-struct SkillMetadataFile {- #[serde(default)]- interface: Option<SkillInterfaceFile>,- #[serde(default)]- dependencies: Option<Dependencies>,- #[serde(default)]- policy: Option<Policy>,-}--#[derive(Default)]-struct LoadedSkillMetadata {- interface: Option<SkillInterface>,- dependencies: Option<SkillDependencies>,- policy: Option<SkillPolicy>,-}--#[derive(Debug, Default, Deserialize)]-struct Dependencies {- #[serde(default)]- tools: Vec<DependencyTool>,-}--#[derive(Debug, Deserialize)]-struct Policy {- #[serde(default)]- allow_implicit_invocation: Option<bool>,- #[serde(default)]- products: Vec<Product>,-}--#[derive(Debug, Default, Deserialize)]-struct DependencyTool {- #[serde(rename = "type")]- kind: Option<String>,- value: Option<String>,- description: Option<String>,- transport: Option<String>,- command: Option<String>,- url: Option<String>,-}--const SKILLS_FILENAME: &str = "SKILL.md";-const SKILLS_METADATA_DIR: &str = "agents";-const SKILLS_METADATA_FILENAME: &str = "openai.yaml";-const MAX_NAME_LEN: usize = 64;-const MAX_QUALIFIED_NAME_LEN: usize = MAX_NAME_LEN * 2 + 1;-const MAX_DESCRIPTION_LEN: usize = 1024;-const MAX_DEPENDENCY_TYPE_LEN: usize = MAX_NAME_LEN;-const MAX_DEPENDENCY_TRANSPORT_LEN: usize = MAX_NAME_LEN;-const MAX_DEPENDENCY_VALUE_LEN: usize = MAX_DESCRIPTION_LEN;-const MAX_DEPENDENCY_DESCRIPTION_LEN: usize = MAX_DESCRIPTION_LEN;-const MAX_DEPENDENCY_COMMAND_LEN: usize = MAX_DESCRIPTION_LEN;-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;--struct ResolvedDiscoveredSkill {- skill: DiscoveredSkill,- path: AbsolutePathBuf,- path_uri: PathUri,-}--#[derive(Debug)]-enum SkillLoadError {- Read(std::io::Error),- Parse(SkillParseError),-}--impl fmt::Display for SkillLoadError {- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {- match self {- Self::Read(error) => write!(f, "failed to read file: {error}"),- Self::Parse(error) => write!(f, "{error}"),- }- }-}--impl Error for SkillLoadError {}--impl From<SkillParseError> for SkillLoadError {- fn from(error: SkillParseError) -> Self {- Self::Parse(error)- }-}--pub struct SkillRoot {- pub path: AbsolutePathBuf,- pub scope: SkillScope,- pub file_system: Arc<dyn ExecutorFileSystem>,- pub plugin_identity: Option<PluginIdentity>,- pub plugin_namespace: Option<String>,- pub plugin_root: Option<AbsolutePathBuf>,- pub discovery_mode: SkillDiscoveryMode,-}--pub async fn load_skills_from_roots<I>(- roots: I,- plugin_skill_snapshots: Option<&crate::PluginSkillSnapshots>,- root_scan_slots: Arc<Semaphore>,-) -> SkillLoadOutcome-where- I: IntoIterator<Item = SkillRoot> + Send,- I::IntoIter: Send,-{- crate::root_loader::load_and_merge_skill_roots(roots, plugin_skill_snapshots, &root_scan_slots)- .boxed()- .await-}--/// One loaded skill root and the filesystem that supplied it.-///-/// This is exposed temporarily while host discovery moves out of `core-skills`; callers should-/// combine snapshots through [`SkillLoadOutcome::from_root_snapshots`].-#[derive(Clone)]-pub struct SkillRootSnapshot {- pub(crate) root: AbsolutePathBuf,- pub(crate) is_agent_plugin: bool,- pub(crate) skills: Vec<SkillMetadata>,- pub(crate) skill_discovery_path_by_path: Arc<HashMap<AbsolutePathBuf, AbsolutePathBuf>>,- pub(crate) errors: Vec<SkillError>,- pub(crate) file_system: Arc<dyn ExecutorFileSystem>,-}--impl SkillRootSnapshot {- pub fn new(- root: AbsolutePathBuf,- skills: Vec<SkillMetadata>,- skill_discovery_path_by_path: Arc<HashMap<AbsolutePathBuf, AbsolutePathBuf>>,- errors: Vec<SkillError>,- file_system: Arc<dyn ExecutorFileSystem>,- ) -> Self {- Self {- root,- is_agent_plugin: false,- skills,- skill_discovery_path_by_path,- errors,- file_system,- }- }-}--pub(crate) async fn load_skill_root(root: SkillRoot) -> SkillRootSnapshot {- let canonical_root =- canonicalize_for_skill_identity(root.file_system.as_ref(), &root.path).await;- let mut outcome = SkillLoadOutcome::default();- load_skills_under_root(&root, &canonical_root, &mut outcome).await;- SkillRootSnapshot {- root: canonical_root,- is_agent_plugin: root.discovery_mode == SkillDiscoveryMode::DirectChildren,- skills: outcome.skills,- skill_discovery_path_by_path: outcome.skill_discovery_path_by_path,- errors: outcome.errors,- file_system: root.file_system,- }-}--async fn canonicalize_for_skill_identity(- fs: &dyn ExecutorFileSystem,- path: &AbsolutePathBuf,-) -> AbsolutePathBuf {- let path_uri = PathUri::from_abs_path(path);- fs.canonicalize(&path_uri, /*sandbox*/ None)- .await- .and_then(|path| path.to_abs_path())- .unwrap_or_else(|_| path.clone())-}--async fn load_skills_under_root(- skill_root: &SkillRoot,- root: &AbsolutePathBuf,- outcome: &mut SkillLoadOutcome,-) {- let fs = skill_root.file_system.as_ref();- let plugin_identity = skill_root.plugin_identity.as_ref();- let plugin_root = match skill_root.plugin_root.as_ref() {- Some(plugin_root) => Some(canonicalize_for_skill_identity(fs, plugin_root).await),- None => None,- };- let directory_symlinks = match skill_root.scope {- SkillScope::User | SkillScope::Repo | SkillScope::Admin => DirectorySymlinkPolicy::Follow,- SkillScope::System => DirectorySymlinkPolicy::Ignore,- };- let SkillDiscovery {- skills,- plugin_roots,- mut namespace_roots,- warnings,- } = discover_skills(- fs,- &PathUri::from_abs_path(root),- // Preserve host discovery behavior: directory aliases are scope-dependent, while hidden- // directories are skipped unless reached through a visible alias.- SkillDiscoveryOptions {- directory_symlinks,- hidden_directories: HiddenDirectoryPolicy::Skip,- mode: skill_root.discovery_mode,- },- )- .await;- for warning in warnings {- error!("{warning}");- }- // With no skills, there is nothing to canonicalize, parse, or namespace-qualify.- if skills.is_empty() {- return;- }- let root_uri = PathUri::from_abs_path(root);- let resolved_plugin_root = plugin_root.as_ref();- let resolved_skills = futures::stream::iter(skills)- .map(|skill| async move {- let path_uri = match fs.canonicalize(&skill.path, /*sandbox*/ None).await {- Ok(path) => path,- Err(err) if skill_root.discovery_mode == SkillDiscoveryMode::DirectChildren => {- error!(- "failed to resolve Agent Plugin skill path {}: {err}",- skill.path- );- return None;- }- Err(_) => skill.path.clone(),- };- let path = match path_uri.to_abs_path() {- Ok(path) => path,- Err(err) => {- error!("failed to convert discovered skill path {path_uri}: {err}");- return None;- }- };- if skill_root.discovery_mode == SkillDiscoveryMode::DirectChildren {- let Some(plugin_root) = resolved_plugin_root else {- error!("Agent Plugin skill root is missing its plugin root");- return None;- };- if !path.as_path().starts_with(plugin_root.as_path()) {- error!(- "Agent Plugin skill path {} resolves outside plugin root {}",- path.display(),- plugin_root.display()- );- return None;- }- match fs.get_metadata(&path_uri, /*sandbox*/ None).await {- Ok(metadata) if metadata.is_file => {}- Ok(_) => {- error!(- "Agent Plugin skill path {} is not a regular file",- path.display()- );- return None;- }- Err(err) => {- error!(- "failed to inspect Agent Plugin skill path {}: {err}",- path.display()- );- return None;- }- }- }- Some(ResolvedDiscoveredSkill {- skill,- path,- path_uri,- })- })- .buffered(MAX_CONCURRENT_SKILL_LOADS)- .filter_map(futures::future::ready)- .collect::<Vec<_>>()- .await;- namespace_roots.extend(resolved_skills.iter().filter_map(|skill| {- (skill.path_uri != skill.skill.path)- .then(|| skill.path_uri.parent())- .flatten()- }));- let skill_paths = resolved_skills- .iter()- .map(|skill| skill.path_uri.clone())- .collect::<Vec<_>>();- let namespace_resolver = async {- match skill_root.plugin_namespace.as_deref() {- Some(namespace) => SkillNamespaceResolver::with_provided_namespace(namespace),- None => {- SkillNamespaceResolver::discover(- fs,- &root_uri,- &skill_paths,- plugin_roots,- namespace_roots,- )- .await- }- }- };- let skill_results = futures::stream::iter(resolved_skills)- .map(|skill| {- let plugin_root = plugin_root.as_ref();- async move {- let discovery_path = skill- .skill- .path- .to_abs_path()- .unwrap_or_else(|_| skill.path.clone());- let result = parse_skill_file(- fs,- &skill.skill,- &skill.path,- &skill.path_uri,- skill_root.scope,- plugin_identity,- plugin_root,- )- .await- .map_err(|err| err.to_string());- (skill.path, skill.path_uri, discovery_path, result)- }- })- .buffered(MAX_CONCURRENT_SKILL_LOADS)- .collect::<Vec<_>>()- .boxed();- let (namespace_resolver, skill_results) = tokio::join!(namespace_resolver, skill_results);- for (path, path_uri, discovery_path, result) in skill_results {- let result = result.and_then(|mut skill| {- skill.name = namespace_resolver- .for_skill(&root_uri, &path_uri)- .qualify(&skill.name);- validate_len(&skill.name, MAX_QUALIFIED_NAME_LEN, "qualified name")- .map_err(|err| err.to_string())?;- Ok(skill)- });- match result {- Ok(skill) => {- Arc::make_mut(&mut outcome.skill_discovery_path_by_path)- .insert(skill.path_to_skills_md.clone(), discovery_path);- outcome.skills.push(skill);- }- Err(err) if skill_root.scope != SkillScope::System => {- outcome.errors.push(SkillError { path, message: err })- }- Err(_) => {}- }- }-}--async fn parse_skill_file(- fs: &dyn ExecutorFileSystem,- skill: &DiscoveredSkill,- path: &AbsolutePathBuf,- path_uri: &PathUri,- scope: SkillScope,- plugin_identity: Option<&PluginIdentity>,- plugin_root: Option<&AbsolutePathBuf>,-) -> Result<SkillMetadata, SkillLoadError> {- let metadata_path = path_uri- .parent()- .and_then(|parent| parent.join(SKILLS_METADATA_DIR).ok())- .and_then(|directory| directory.join(SKILLS_METADATA_FILENAME).ok());- let metadata = match &skill.metadata {- SkillMetadataDiscovery::Present(_) => metadata_path.map(SkillMetadataDiscovery::Present),- SkillMetadataDiscovery::Probe(_) => metadata_path.map(SkillMetadataDiscovery::Probe),- SkillMetadataDiscovery::Absent => None,- }- .unwrap_or(SkillMetadataDiscovery::Absent);- let (contents, loaded_metadata) = tokio::join!(- fs.read_file_text(path_uri, /*sandbox*/ None),- load_skill_metadata(fs, path, &metadata, plugin_root),- );- let contents = contents.map_err(SkillLoadError::Read)?;- let ParsedSkillFrontmatter {- name: base_name,- description,- short_description,- } = parse_skill_frontmatter_metadata(&contents, || default_skill_name(path))?;- let LoadedSkillMetadata {- interface,- dependencies,- policy,- } = loaded_metadata;-- Ok(SkillMetadata {- name: base_name,- description,- short_description,- interface,- dependencies,- policy,- path_to_skills_md: path.clone(),- scope,- plugin_id: plugin_identity.map(|identity| identity.plugin_id.clone()),- remote_plugin_id: plugin_identity.and_then(|identity| identity.remote_plugin_id.clone()),- })-}--fn default_skill_name(path: &AbsolutePathBuf) -> String {- path.parent()- .and_then(|parent| {- parent- .file_name()- .and_then(|name| name.to_str())- .map(sanitize_single_line)- })- .filter(|value| !value.is_empty())- .unwrap_or_else(|| "skill".to_string())-}--async fn load_skill_metadata(- fs: &dyn ExecutorFileSystem,- skill_path: &AbsolutePathBuf,- metadata: &SkillMetadataDiscovery,- plugin_root: Option<&AbsolutePathBuf>,-) -> LoadedSkillMetadata {- // Fail open: optional metadata should not block loading SKILL.md.- let Some(skill_dir) = skill_path.parent() else {- return LoadedSkillMetadata::default();- };- let metadata_path_uri = match metadata {- SkillMetadataDiscovery::Present(path) => path,- SkillMetadataDiscovery::Absent => return LoadedSkillMetadata::default(),- SkillMetadataDiscovery::Probe(path) => {- match fs.get_metadata(path, /*sandbox*/ None).await {- Ok(metadata) if metadata.is_file => {}- Ok(_) => return LoadedSkillMetadata::default(),- Err(error) if error.kind() == io::ErrorKind::NotFound => {- return LoadedSkillMetadata::default();- }- Err(error) => {- tracing::warn!(- "ignoring {path}: failed to stat {label}: {error}",- path = path,- label = SKILLS_METADATA_FILENAME- );- return LoadedSkillMetadata::default();- }- }- path- }- };-- let contents = match fs.read_file_text(metadata_path_uri, /*sandbox*/ None).await {- Ok(contents) => contents,- Err(error) => {- tracing::warn!(- "ignoring {path}: failed to read {label}: {error}",- path = metadata_path_uri,- label = SKILLS_METADATA_FILENAME- );- return LoadedSkillMetadata::default();- }- };-- let parsed: SkillMetadataFile = {- let _guard = AbsolutePathBufGuard::new(skill_dir.as_path());- match serde_yaml::from_str(&contents) {- Ok(parsed) => parsed,- Err(error) => {- tracing::warn!(- "ignoring {path}: invalid {label}: {error}",- path = metadata_path_uri,- label = SKILLS_METADATA_FILENAME- );- return LoadedSkillMetadata::default();- }- }- };-- let SkillMetadataFile {- interface,- dependencies,- policy,- } = parsed;- let asset_policy = match plugin_root {- Some(plugin_root) => SkillInterfaceAssetPolicy::PluginShared { plugin_root },- None => SkillInterfaceAssetPolicy::LocalOnly,- };- LoadedSkillMetadata {- interface: resolve_skill_interface(interface, &skill_dir, asset_policy),- dependencies: resolve_dependencies(dependencies),- policy: resolve_policy(policy),- }-}--fn resolve_dependencies(dependencies: Option<Dependencies>) -> Option<SkillDependencies> {- let dependencies = dependencies?;- let tools: Vec<SkillToolDependency> = dependencies- .tools- .into_iter()- .filter_map(resolve_dependency_tool)- .collect();- if tools.is_empty() {- None- } else {- Some(SkillDependencies { tools })- }-}--fn resolve_policy(policy: Option<Policy>) -> Option<SkillPolicy> {- policy.map(|policy| SkillPolicy {- allow_implicit_invocation: policy.allow_implicit_invocation,- products: policy.products,- })-}--fn resolve_dependency_tool(tool: DependencyTool) -> Option<SkillToolDependency> {- let r#type = resolve_required_str(- tool.kind,- MAX_DEPENDENCY_TYPE_LEN,- "dependencies.tools.type",- )?;- let value = resolve_required_str(- tool.value,- MAX_DEPENDENCY_VALUE_LEN,- "dependencies.tools.value",- )?;- let description = resolve_str(- tool.description,- MAX_DEPENDENCY_DESCRIPTION_LEN,- "dependencies.tools.description",- );- let transport = resolve_str(- tool.transport,- MAX_DEPENDENCY_TRANSPORT_LEN,- "dependencies.tools.transport",- );- let command = resolve_str(- tool.command,- MAX_DEPENDENCY_COMMAND_LEN,- "dependencies.tools.command",- );- let url = resolve_str(tool.url, MAX_DEPENDENCY_URL_LEN, "dependencies.tools.url");-- Some(SkillToolDependency {- r#type,- value,- description,- transport,- command,- url,- })-}--fn sanitize_single_line(raw: &str) -> String {- raw.split_whitespace().collect::<Vec<_>>().join(" ")-}--fn validate_len(- value: &str,- max_len: usize,- field_name: &'static str,-) -> Result<(), SkillParseError> {- if value.is_empty() {- return Err(SkillParseError::MissingField(field_name));- }- if value.chars().count() > max_len {- return Err(SkillParseError::InvalidField {- field: field_name,- reason: format!("exceeds maximum length of {max_len} characters"),- });- }- Ok(())-}--fn resolve_str(value: Option<String>, max_len: usize, field: &'static str) -> Option<String> {- let value = value?;- let value = sanitize_single_line(&value);- if value.is_empty() {- tracing::warn!("ignoring {field}: value is empty");- return None;- }- if value.chars().count() > max_len {- tracing::warn!("ignoring {field}: exceeds maximum length of {max_len} characters");- return None;- }- Some(value)-}--fn resolve_required_str(- value: Option<String>,- max_len: usize,- field: &'static str,-) -> Option<String> {- let Some(value) = value else {- tracing::warn!("ignoring {field}: value is missing");- return None;- };- resolve_str(Some(value), max_len, field)-}--#[cfg(test)]-#[path = "loader_tests.rs"]-mod tests;diff --git a/codex-rs/core-skills/src/loader/discovery.rs b/codex-rs/core-skills/src/loader/discovery.rsdeleted file mode 100644index cadc8218c0..0000000000--- a/codex-rs/core-skills/src/loader/discovery.rs+++ /dev/null@@ -1,219 +0,0 @@-use std::collections::HashSet;-use std::io;--use codex_exec_server::ExecutorFileSystem;-use codex_exec_server::WalkEntryKind;-use codex_exec_server::WalkOptions;-use codex_utils_path_uri::PathUri;-use codex_utils_plugins::DISCOVERABLE_PLUGIN_MANIFEST_PATHS;-use codex_utils_plugins::SkillDiscoveryMode;--use super::MAX_SCAN_DEPTH;-use super::MAX_SKILLS_DIRS_PER_ROOT;-use super::SKILLS_FILENAME;-use super::SKILLS_METADATA_DIR;-use super::SKILLS_METADATA_FILENAME;--const MAX_SKILLS_ENTRIES_PER_ROOT: usize = 20_000;-pub(super) const MAX_CONCURRENT_SKILL_LOADS: usize = 64;--pub(super) enum DirectorySymlinkPolicy {- Follow,- Ignore,-}--pub(super) enum HiddenDirectoryPolicy {- Include,- Skip,-}--pub(super) struct SkillDiscoveryOptions {- pub directory_symlinks: DirectorySymlinkPolicy,- pub hidden_directories: HiddenDirectoryPolicy,- pub mode: SkillDiscoveryMode,-}--pub(super) struct SkillDiscovery {- pub skills: Vec<DiscoveredSkill>,- pub plugin_roots: HashSet<PathUri>,- pub namespace_roots: HashSet<PathUri>,- pub warnings: Vec<String>,-}--pub(super) struct DiscoveredSkill {- pub path: PathUri,- pub metadata: SkillMetadataDiscovery,-}--pub(super) enum SkillMetadataDiscovery {- Present(PathUri),- Absent,- Probe(PathUri),-}--pub(super) async fn discover_skills(- file_system: &dyn ExecutorFileSystem,- root: &PathUri,- options: SkillDiscoveryOptions,-) -> SkillDiscovery {- let empty_discovery = || SkillDiscovery {- skills: Vec::new(),- plugin_roots: HashSet::new(),- namespace_roots: HashSet::new(),- warnings: Vec::new(),- };- let walk = match file_system- .walk(- root,- WalkOptions {- max_depth: match options.mode {- SkillDiscoveryMode::Recursive => MAX_SCAN_DEPTH,- SkillDiscoveryMode::DirectChildren => 2,- },- max_directories: MAX_SKILLS_DIRS_PER_ROOT,- max_entries: MAX_SKILLS_ENTRIES_PER_ROOT,- follow_directory_symlinks: matches!(- options.directory_symlinks,- DirectorySymlinkPolicy::Follow- ),- prune_hidden_directories: matches!(- options.hidden_directories,- HiddenDirectoryPolicy::Skip- ),- },- /*sandbox*/ None,- )- .await- {- Ok(walk) => walk,- Err(error) if error.kind() == io::ErrorKind::NotFound => return empty_discovery(),- Err(error) => {- let mut discovery = empty_discovery();- discovery- .warnings- .push(format!("failed to walk skills root {root}: {error:#}"));- return discovery;- }- };-- let inventory_complete = !walk.truncated && walk.errors.is_empty();- let mut warnings = walk- .errors- .into_iter()- .map(|error| {- format!(- "failed to scan skill path {}: {}",- error.path, error.message- )- })- .collect::<Vec<_>>();- if walk.truncated {- warnings.push(format!(- "skills scan reached its traversal limit (root: {root})"- ));- }-- let skip_hidden = matches!(options.hidden_directories, HiddenDirectoryPolicy::Skip);- let mut skill_files = Vec::new();- let mut file_paths = HashSet::new();- let mut metadata_directory_parents = HashSet::new();- let mut plugin_roots = HashSet::new();- for entry in walk.entries {- if skip_hidden && has_hidden_ancestor_below_root(&entry.path, root) {- continue;- }- match entry.kind {- WalkEntryKind::Directory => {- if entry- .path- .basename()- .is_some_and(|name| name.eq_ignore_ascii_case(SKILLS_METADATA_DIR))- && let Some(skill_dir) = entry.path.parent()- {- metadata_directory_parents.insert(skill_dir);- }- if DISCOVERABLE_PLUGIN_MANIFEST_PATHS- .iter()- .any(|path| path.split('/').next() == entry.path.basename().as_deref())- && let Some(plugin_root) = entry.path.parent()- {- plugin_roots.insert(plugin_root);- }- }- WalkEntryKind::File => {- file_paths.insert(entry.path.clone());- if entry.path.basename().as_deref() == Some(SKILLS_FILENAME)- && (options.mode == SkillDiscoveryMode::Recursive- || is_direct_child_skill_path(&entry.path, root))- {- skill_files.push(entry.path);- }- }- }- }- let skills = skill_files- .into_iter()- .map(|path| DiscoveredSkill {- metadata: discover_skill_metadata(- &path,- &file_paths,- &metadata_directory_parents,- inventory_complete,- ),- path,- })- .collect();-- SkillDiscovery {- skills,- plugin_roots,- namespace_roots: HashSet::from([root.clone()]),- warnings,- }-}--fn is_direct_child_skill_path(path: &PathUri, root: &PathUri) -> bool {- path.parent().and_then(|parent| parent.parent()).as_ref() == Some(root)-}--fn has_hidden_ancestor_below_root(path: &PathUri, root: &PathUri) -> bool {- let mut ancestor = path.parent();- while let Some(current) = ancestor {- if ¤t == root {- return false;- }- if current.basename().is_some_and(|name| name.starts_with('.')) {- return true;- }- ancestor = current.parent();- }- false-}--fn discover_skill_metadata(- skill_path: &PathUri,- file_paths: &HashSet<PathUri>,- metadata_directory_parents: &HashSet<PathUri>,- inventory_complete: bool,-) -> SkillMetadataDiscovery {- let Some(skill_dir) = skill_path.parent() else {- return SkillMetadataDiscovery::Absent;- };- let Ok(metadata_dir) = skill_dir.join(SKILLS_METADATA_DIR) else {- return SkillMetadataDiscovery::Absent;- };- let Ok(metadata_path) = metadata_dir.join(SKILLS_METADATA_FILENAME) else {- return SkillMetadataDiscovery::Absent;- };- if file_paths.contains(&metadata_path) {- return SkillMetadataDiscovery::Present(metadata_path);- }-- if inventory_complete && !metadata_directory_parents.contains(&skill_dir) {- SkillMetadataDiscovery::Absent- } else {- // A complete walk proves ordinary absence, but keep a filesystem probe for case aliases,- // file symlinks omitted by the walk, and incomplete inventories.- SkillMetadataDiscovery::Probe(metadata_path)- }-}diff --git a/codex-rs/core-skills/src/loader/environment.rs b/codex-rs/core-skills/src/loader/environment.rsdeleted file mode 100644index fa950ec7b1..0000000000--- a/codex-rs/core-skills/src/loader/environment.rs+++ /dev/null@@ -1,252 +0,0 @@-use std::io;--use codex_exec_server::ExecutorFileSystem;-use codex_protocol::protocol::Product;-pub use codex_skills::EnvironmentSkillMetadata;-use codex_skills::ParsedSkillFrontmatter;-use codex_skills::parse_skill_frontmatter_metadata;-use codex_utils_path_uri::PathUri;-use futures::StreamExt;--use crate::model::SkillDependencies;-use crate::model::SkillPolicy;--use super::MAX_QUALIFIED_NAME_LEN;-use super::SkillMetadataFile;-use super::discovery::DirectorySymlinkPolicy;-use super::discovery::DiscoveredSkill;-use super::discovery::HiddenDirectoryPolicy;-use super::discovery::MAX_CONCURRENT_SKILL_LOADS;-use super::discovery::SkillDiscoveryOptions;-use super::discovery::SkillMetadataDiscovery;-use super::discovery::discover_skills;-use super::namespace::SkillNamespaceResolver;-use super::resolve_dependencies;-use super::resolve_policy;-use super::sanitize_single_line;-use super::validate_len;--struct ParsedEnvironmentSkill {- path_to_skills_md: PathUri,- base_name: String,- description: String,- short_description: Option<String>,- dependencies: Option<SkillDependencies>,- policy: Option<SkillPolicy>,-}--impl ParsedEnvironmentSkill {- async fn load(- file_system: &dyn ExecutorFileSystem,- skill: &DiscoveredSkill,- ) -> Result<Self, String> {- let (contents, discovered_metadata) = match &skill.metadata {- SkillMetadataDiscovery::Present(metadata_path) => {- let (contents, metadata) = tokio::join!(- read_skill_contents(file_system, &skill.path),- read_skill_metadata(file_system, metadata_path),- );- (contents?, metadata)- }- SkillMetadataDiscovery::Absent | SkillMetadataDiscovery::Probe(_) => (- read_skill_contents(file_system, &skill.path).await?,- (None, None),- ),- };- let ParsedSkillFrontmatter {- name: base_name,- description,- short_description,- } = parse_skill_frontmatter_metadata(&contents, || default_skill_name(&skill.path))- .map_err(|err| err.to_string())?;- let (dependencies, policy) = match &skill.metadata {- SkillMetadataDiscovery::Present(_) | SkillMetadataDiscovery::Absent => {- discovered_metadata- }- SkillMetadataDiscovery::Probe(metadata_path) => {- probe_skill_metadata(file_system, metadata_path).await- }- };-- Ok(Self {- path_to_skills_md: skill.path.clone(),- base_name,- description,- short_description,- dependencies,- policy,- })- }-}--#[derive(Debug, Default)]-pub struct EnvironmentSkillLoadOutcome {- pub skills: Vec<EnvironmentSkillMetadata>,- pub warnings: Vec<String>,-}--/// Discovers skills without converting environment-owned paths to host paths.-#[tracing::instrument(- name = "skills.environment.load",- level = "info",- skip_all,- fields(skill_count = tracing::field::Empty)-)]-pub async fn load_environment_skills_from_root(- file_system: &dyn ExecutorFileSystem,- root: &PathUri,- restriction_product: Option<Product>,-) -> EnvironmentSkillLoadOutcome {- let mut outcome = EnvironmentSkillLoadOutcome::default();- let discovery = discover_skills(- file_system,- root,- // Preserve environment discovery behavior by following directory aliases and including- // hidden directories exposed by the executor.- SkillDiscoveryOptions {- directory_symlinks: DirectorySymlinkPolicy::Follow,- hidden_directories: HiddenDirectoryPolicy::Include,- mode: codex_utils_plugins::SkillDiscoveryMode::Recursive,- },- )- .await;- tracing::Span::current().record("skill_count", discovery.skills.len());- outcome.warnings.extend(discovery.warnings);- if discovery.skills.is_empty() {- return outcome;- }-- let skill_paths = discovery- .skills- .iter()- .map(|skill| skill.path.clone())- .collect::<Vec<_>>();- let namespace_resolver = SkillNamespaceResolver::discover(- file_system,- root,- &skill_paths,- discovery.plugin_roots,- discovery.namespace_roots,- );-- // Remote executors can multiplex these independent per-skill reads, so polling a bounded- // number together allows the I/O for each skill and its metadata to happen concurrently.- let skill_results = futures::stream::iter(discovery.skills)- .map(|skill| {- let path = skill.path.clone();- async move {- (- path,- ParsedEnvironmentSkill::load(file_system, &skill).await,- )- }- })- .buffered(MAX_CONCURRENT_SKILL_LOADS)- .collect::<Vec<_>>();- let (namespace_resolver, skill_results) = tokio::join!(namespace_resolver, skill_results);-- for (path, result) in skill_results {- let result = result.and_then(|skill| {- let name = namespace_resolver- .for_skill(root, &skill.path_to_skills_md)- .qualify(&skill.base_name);- validate_len(&name, MAX_QUALIFIED_NAME_LEN, "qualified name")- .map_err(|err| err.to_string())?;-- Ok(EnvironmentSkillMetadata {- path_to_skills_md: skill.path_to_skills_md,- name,- description: skill.description,- short_description: skill.short_description,- dependencies: skill.dependencies,- policy: skill.policy,- })- });- match result {- Ok(skill) if skill.matches_product_restriction(restriction_product) => {- outcome.skills.push(skill);- }- Ok(_) => {}- Err(message) => outcome.warnings.push(format!(- "Failed to load environment skill at {path}: {message}"- )),- }- }- outcome.skills.sort_by(|left, right| {- left.name.cmp(&right.name).then_with(|| {- left.path_to_skills_md- .to_string()- .cmp(&right.path_to_skills_md.to_string())- })- });- outcome-}--async fn read_skill_contents(- file_system: &dyn ExecutorFileSystem,- skill_path: &PathUri,-) -> Result<String, String> {- file_system- .read_file_text(skill_path, /*sandbox*/ None)- .await- .map_err(|err| format!("failed to read file: {err}"))-}--async fn probe_skill_metadata(- file_system: &dyn ExecutorFileSystem,- metadata_path: &PathUri,-) -> (Option<SkillDependencies>, Option<SkillPolicy>) {- match file_system- .get_metadata(metadata_path, /*sandbox*/ None)- .await- {- Ok(metadata) if metadata.is_file => {}- Ok(_) => return (None, None),- Err(error) if error.kind() == io::ErrorKind::NotFound => return (None, None),- Err(error) => {- tracing::warn!("ignoring {metadata_path}: failed to stat metadata: {error}");- return (None, None);- }- }- read_skill_metadata(file_system, metadata_path).await-}--async fn read_skill_metadata(- file_system: &dyn ExecutorFileSystem,- metadata_path: &PathUri,-) -> (Option<SkillDependencies>, Option<SkillPolicy>) {- let contents = match file_system- .read_file_text(metadata_path, /*sandbox*/ None)- .await- {- Ok(contents) => contents,- Err(error) => {- tracing::warn!("ignoring {metadata_path}: failed to read metadata: {error}");- return (None, None);- }- };- let parsed: SkillMetadataFile = match serde_yaml::from_str(&contents) {- Ok(parsed) => parsed,- Err(error) => {- tracing::warn!("ignoring {metadata_path}: invalid metadata: {error}");- return (None, None);- }- };-- (- resolve_dependencies(parsed.dependencies),- resolve_policy(parsed.policy),- )-}--fn default_skill_name(path: &PathUri) -> String {- path.parent()- .and_then(|parent| parent.basename())- .map(|name| sanitize_single_line(&name))- .filter(|name| !name.is_empty())- .unwrap_or_else(|| "skill".to_string())-}--#[cfg(test)]-#[path = "environment_tests.rs"]-mod tests;diff --git a/codex-rs/core-skills/src/loader/environment_tests.rs b/codex-rs/core-skills/src/loader/environment_tests.rsdeleted file mode 100644index a817830b37..0000000000--- a/codex-rs/core-skills/src/loader/environment_tests.rs+++ /dev/null@@ -1,78 +0,0 @@-use std::fs;--use codex_exec_server::LOCAL_FS;-use codex_protocol::protocol::Product;-use codex_utils_path_uri::PathUri;-use pretty_assertions::assert_eq;-use tempfile::tempdir;--use crate::model::SkillDependencies;-use crate::model::SkillPolicy;-use crate::model::SkillToolDependency;--use super::EnvironmentSkillMetadata;-use super::load_environment_skills_from_root;--#[tokio::test]-async fn loads_plugin_namespace_dependencies_and_policy() {- let root = tempdir().expect("tempdir");- let skill_dir = root.path().join("skills/deploy");- fs::create_dir_all(root.path().join(".codex-plugin")).expect("manifest dir");- fs::create_dir_all(skill_dir.join("agents")).expect("metadata dir");- fs::write(- root.path().join(".codex-plugin/plugin.json"),- r#"{"name":"demo-plugin"}"#,- )- .expect("manifest");- fs::write(- skill_dir.join("SKILL.md"),- "---\nname: deploy\ndescription: Deploy the service.\n---\n",- )- .expect("skill");- fs::write(- skill_dir.join("agents/openai.yaml"),- r#"-dependencies:- tools:- - type: mcp- value: deploy-server- description: Deploy MCP-policy:- allow_implicit_invocation: false- products: [codex]-"#,- )- .expect("metadata");-- let root_uri = PathUri::from_host_native_path(root.path()).expect("root URI");- let outcome =- load_environment_skills_from_root(LOCAL_FS.as_ref(), &root_uri, Some(Product::Codex)).await;-- assert_eq!(- outcome.skills,- vec![EnvironmentSkillMetadata {- path_to_skills_md: PathUri::from_host_native_path(skill_dir.join("SKILL.md"),).unwrap(),- name: "demo-plugin:deploy".to_string(),- description: "Deploy the service.".to_string(),- short_description: None,- dependencies: Some(SkillDependencies {- tools: vec![SkillToolDependency {- r#type: "mcp".to_string(),- value: "deploy-server".to_string(),- description: Some("Deploy MCP".to_string()),- transport: None,- command: None,- url: None,- }],- }),- policy: Some(SkillPolicy {- allow_implicit_invocation: Some(false),- products: vec![Product::Codex],- }),- }]- );- let filtered =- load_environment_skills_from_root(LOCAL_FS.as_ref(), &root_uri, Some(Product::Chatgpt))- .await;- assert!(filtered.skills.is_empty());-}diff --git a/codex-rs/core-skills/src/loader/namespace.rs b/codex-rs/core-skills/src/loader/namespace.rsdeleted file mode 100644index fa00b1005d..0000000000--- a/codex-rs/core-skills/src/loader/namespace.rs+++ /dev/null@@ -1,182 +0,0 @@-use codex_exec_server::ExecutorFileSystem;-use codex_utils_path_uri::PathUri;-use codex_utils_plugins::plugin_namespace_for_root_uri;-use futures::StreamExt;-use std::collections::HashMap;-use std::collections::HashSet;--use super::discovery::MAX_CONCURRENT_SKILL_LOADS;--/// Resolves the namespace prefix applied to skill names during one skills scan.-///-/// A plugin namespace is the plugin name from the nearest valid plugin manifest-/// above a skill path. For example, a skill named `search` beneath a plugin named-/// `sample` is exposed as `sample:search`.-///-/// Resolving the namespace separately for every `SKILL.md` repeats the same-/// ancestor manifest probes for sibling skills. This resolver resolves relevant-/// roots once per scan, then selects the nearest matching root for each skill.-///-/// Namespace precedence is:-///-/// 1. an explicitly provided plugin namespace;-/// 2. the deepest matching canonical symlink root or nested plugin root;-/// 3. the namespace inherited from the scanned skills root.-pub(crate) struct SkillNamespaceResolver {- inherited_namespace: ResolvedSkillNamespace,- nested_namespaces: Vec<(PathUri, ResolvedSkillNamespace)>,-}--impl SkillNamespaceResolver {- /// Builds a resolver whose explicit plugin-owned namespace overrides discovery.- pub(crate) fn with_provided_namespace(namespace: &str) -> Self {- Self {- inherited_namespace: ResolvedSkillNamespace::Plugin(namespace.to_string()),- nested_namespaces: Vec::new(),- }- }-- pub(crate) async fn discover(- fs: &dyn ExecutorFileSystem,- root: &PathUri,- skill_paths: &[PathUri],- plugin_roots: HashSet<PathUri>,- namespace_roots: HashSet<PathUri>,- ) -> Self {- // Only probe plugin roots above loaded skills; unused siblings cannot affect names.- let mut skill_ancestors = HashSet::new();- for skill_path in skill_paths {- let mut ancestor = skill_path.parent();- while let Some(path) = ancestor {- skill_ancestors.insert(path.clone());- ancestor = path.parent();- }- }- let plugin_roots = plugin_roots- .into_iter()- .filter(|plugin_root| skill_ancestors.contains(plugin_root))- .collect::<HashSet<_>>();-- // The scan root is already the fallback above if nothing else matches, exclude from the search.- let namespace_roots = namespace_roots- .into_iter()- .filter(|namespace_root| namespace_root != root)- .collect::<Vec<_>>();- let namespace_root_set = namespace_roots.iter().cloned().collect::<HashSet<_>>();- let plugin_roots = plugin_roots- .into_iter()- .filter(|plugin_root| plugin_root != root && !namespace_root_set.contains(plugin_root))- .collect::<Vec<_>>();-- let lookup_roots = std::iter::once(root.clone())- .chain(namespace_roots.iter().cloned())- .collect::<Vec<_>>();- let mut pending_lookups = lookup_roots- .iter()- .cloned()- .map(|lookup_root| (lookup_root.clone(), lookup_root))- .collect::<Vec<_>>();- let mut direct_plugin_roots = plugin_roots.iter().cloned().collect::<HashSet<_>>();- let mut namespaces_by_root = HashMap::new();- let mut namespaces_by_lookup_root = HashMap::new();- while !pending_lookups.is_empty() {- let probe_roots = pending_lookups- .iter()- .map(|(_, ancestor)| ancestor.clone())- .chain(direct_plugin_roots.drain())- .filter(|ancestor| !namespaces_by_root.contains_key(ancestor))- .collect::<HashSet<_>>();- namespaces_by_root.extend(- futures::stream::iter(probe_roots)- .map(|manifest_root| async move {- let namespace = plugin_namespace_for_root_uri(fs, &manifest_root).await;- (manifest_root, namespace)- })- .buffered(MAX_CONCURRENT_SKILL_LOADS)- .collect::<HashMap<_, _>>()- .await,- );-- let mut next_lookups = Vec::new();- for (lookup_root, ancestor) in pending_lookups {- match namespaces_by_root.get(&ancestor) {- Some(Some(namespace)) => {- namespaces_by_lookup_root.insert(lookup_root, Some(namespace.clone()));- }- Some(None) => match ancestor.parent() {- Some(parent) => next_lookups.push((lookup_root, parent)),- None => {- namespaces_by_lookup_root.insert(lookup_root, None);- }- },- None => unreachable!("pending namespace ancestor was not probed"),- }- }- pending_lookups = next_lookups;- }-- // Ordinary descendants fall back to the nearest valid manifest at or above the scan root.- let inherited_namespace = namespaces_by_lookup_root- .get(root)- .and_then(Option::as_ref)- .cloned()- .map(ResolvedSkillNamespace::Plugin)- .unwrap_or(ResolvedSkillNamespace::Plain);- let namespace_lookups = namespace_roots.into_iter().map(|namespace_root| {- let namespace = namespaces_by_lookup_root- .get(&namespace_root)- .and_then(Option::as_ref)- .cloned()- .map(ResolvedSkillNamespace::Plugin)- .unwrap_or(ResolvedSkillNamespace::Plain);- (namespace_root, namespace)- });- // Invalid nested manifests are omitted, so the deepest remaining match wins.- let plugin_lookups = plugin_roots.into_iter().filter_map(|plugin_root| {- namespaces_by_root- .get(&plugin_root)- .and_then(Option::as_ref)- .cloned()- .map(|namespace| (plugin_root, ResolvedSkillNamespace::Plugin(namespace)))- });- let nested_namespaces = namespace_lookups.chain(plugin_lookups).collect();-- Self {- inherited_namespace,- nested_namespaces,- }- }-- pub(crate) fn for_skill(&self, root: &PathUri, path: &PathUri) -> &ResolvedSkillNamespace {- // Ancestor symlink targets cannot override skills still owned by the scan root.- let path_is_under_root = path.starts_with(root);- // The deepest matching path prefix is the nearest applicable namespace.- self.nested_namespaces- .iter()- .filter(|(namespace_root, _)| {- path.starts_with(namespace_root)- && (!path_is_under_root || !root.starts_with(namespace_root))- })- .max_by_key(|(namespace_root, _)| namespace_root.ancestors().count())- .map(|(_, namespace)| namespace)- .unwrap_or(&self.inherited_namespace)- }-}--/// The completed namespace resolution for a skill root.-#[derive(Clone, Debug, Eq, PartialEq)]-pub(crate) enum ResolvedSkillNamespace {- /// No plugin namespace applies to matching skills.- Plain,- /// Qualify matching skill names with this plugin namespace.- Plugin(String),-}--impl ResolvedSkillNamespace {- pub(crate) fn qualify(&self, base_name: &str) -> String {- match self {- Self::Plain => base_name.to_string(),- Self::Plugin(namespace) => format!("{namespace}:{base_name}"),- }- }-}diff --git a/codex-rs/core-skills/src/loader_tests.rs b/codex-rs/core-skills/src/loader_tests.rsdeleted file mode 100644index 9f09cbfdf6..0000000000--- a/codex-rs/core-skills/src/loader_tests.rs+++ /dev/null@@ -1,2089 +0,0 @@-use super::*;-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::Product;-use codex_protocol::protocol::SkillScope;-use codex_utils_absolute_path::AbsolutePathBuf;-use codex_utils_absolute_path::test_support::PathBufExt;-use codex_utils_absolute_path::test_support::PathExt;-use codex_utils_path_uri::PathUri;-use dunce::canonicalize as canonicalize_path;-use pretty_assertions::assert_eq;-use std::fs;-use std::path::Path;-use std::path::PathBuf;-use std::sync::Arc;-use std::sync::atomic::AtomicUsize;-use std::sync::atomic::Ordering;-use tempfile::TempDir;-use tokio::sync::Notify;-use tokio::sync::Semaphore;--const REPO_ROOT_CONFIG_DIR_NAME: &str = ".codex";-const SKILLS_DIR_NAME: &str = "skills";--struct BlockingRepoSkillRootFileSystem {- inner: Arc<dyn ExecutorFileSystem>,- blocked_walk_root: Option<PathUri>,- blocked_walk_gate: Semaphore,- walks_started: AtomicUsize,- walk_started: Notify,-}--impl ExecutorFileSystem for BlockingRepoSkillRootFileSystem {- 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> {- self.inner.get_metadata(path, sandbox)- }-- 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.walks_started.fetch_add(/*val*/ 1, Ordering::AcqRel);- self.walk_started.notify_waiters();- if self.blocked_walk_root.as_ref() != Some(path) {- return self.inner.walk(path, options, sandbox);- }- Box::pin(async move {- self.blocked_walk_gate- .acquire()- .await- .expect("blocked walk gate should remain open")- .forget();- self.inner.walk(path, options, sandbox).await- })- }-- 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)- }-}--async fn load_skills_for_test<I>(roots: I) -> SkillLoadOutcome-where- I: IntoIterator<Item = SkillRoot> + Send,- I::IntoIter: Send,-{- super::load_skills_from_roots(- roots,- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await-}--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 {- canonicalize_path(path)- .unwrap_or_else(|_| path.to_path_buf())- .abs()-}-fn write_skill(codex_home: &TempDir, dir: &str, name: &str, description: &str) -> PathBuf {- write_skill_at(&codex_home.path().join("skills"), dir, name, description)-}--fn write_system_skill(codex_home: &TempDir, dir: &str, name: &str, description: &str) -> PathBuf {- write_skill_at(- &codex_home.path().join("skills/.system"),- dir,- name,- description,- )-}--fn write_skill_at(root: &Path, dir: &str, name: &str, description: &str) -> PathBuf {- let skill_dir = root.join(dir);- fs::create_dir_all(&skill_dir).unwrap();- let indented_description = description.replace('\n', "\n ");- let content =- format!("---\nname: {name}\ndescription: |-\n {indented_description}\n---\n\n# Body\n");- let path = skill_dir.join(SKILLS_FILENAME);- fs::write(&path, content).unwrap();- path-}--fn write_raw_skill_at(root: &Path, dir: &str, frontmatter: &str) -> PathBuf {- let skill_dir = root.join(dir);- fs::create_dir_all(&skill_dir).unwrap();- let path = skill_dir.join(SKILLS_FILENAME);- let content = format!("---\n{frontmatter}\n---\n\n# Body\n");- fs::write(&path, content).unwrap();- path-}--fn write_skill_metadata_at(skill_dir: &Path, contents: &str) -> PathBuf {- let path = skill_dir- .join(SKILLS_METADATA_DIR)- .join(SKILLS_METADATA_FILENAME);- if let Some(parent) = path.parent() {- fs::create_dir_all(parent).unwrap();- }- fs::write(&path, contents).unwrap();- path-}--fn write_skill_interface_at(skill_dir: &Path, contents: &str) -> PathBuf {- write_skill_metadata_at(skill_dir, contents)-}--fn write_plugin_manifest(plugin_root: &Path, contents: &str) {- let manifest_path = plugin_root.join(".codex-plugin/plugin.json");- fs::create_dir_all(manifest_path.parent().expect("manifest parent")).unwrap();- fs::write(manifest_path, contents).unwrap();-}--async fn load_user_skills_root(root: &Path) -> SkillLoadOutcome {- load_skills_from_roots(- [SkillRoot {- path: root.abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await-}--fn expected_user_skill(path: &Path, name: &str, description: &str) -> SkillMetadata {- SkillMetadata {- name: name.to_string(),- description: description.to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }-}--#[tokio::test]-async fn loads_skill_dependencies_metadata_from_yaml() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_skill(&codex_home, "demo", "dep-skill", "from json");- let skill_dir = skill_path.parent().expect("skill dir");-- write_skill_metadata_at(- skill_dir,- r#"-{- "dependencies": {- "tools": [- {- "type": "mcp",- "value": "github",- "description": "GitHub MCP server",- "transport": "streamable_http",- "url": "https://example.com/mcp"- },- {- "type": "cli",- "value": "gh",- "description": "GitHub CLI"- },- {- "type": "mcp",- "value": "local-gh",- "description": "Local GH MCP server",- "transport": "stdio",- "command": "gh-mcp"- }- ]- }-}-"#,- );-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "dep-skill".to_string(),- description: "from json".to_string(),- short_description: None,- interface: None,- dependencies: Some(SkillDependencies {- tools: vec![- SkillToolDependency {- r#type: "mcp".to_string(),- value: "github".to_string(),- description: Some("GitHub MCP server".to_string()),- transport: Some("streamable_http".to_string()),- command: None,- url: Some("https://example.com/mcp".to_string()),- },- SkillToolDependency {- r#type: "cli".to_string(),- value: "gh".to_string(),- description: Some("GitHub CLI".to_string()),- transport: None,- command: None,- url: None,- },- SkillToolDependency {- r#type: "mcp".to_string(),- value: "local-gh".to_string(),- description: Some("Local GH MCP server".to_string()),- transport: Some("stdio".to_string()),- command: Some("gh-mcp".to_string()),- url: None,- },- ],- }),- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn loads_skill_interface_metadata_from_yaml() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_skill(&codex_home, "demo", "ui-skill", "from json");- let skill_dir = skill_path.parent().expect("skill dir");- let normalized_skill_dir = normalized(skill_dir);-- write_skill_interface_at(- skill_dir,- r##"-interface:- display_name: "UI Skill"- short_description: " short desc "- icon_small: "./assets/small-400px.png"- icon_large: "./assets/large-logo.svg"- brand_color: "#3B82F6"- default_prompt: " default prompt "-"##,- );-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- let user_skills: Vec<SkillMetadata> = outcome- .skills- .into_iter()- .filter(|skill| skill.scope == SkillScope::User)- .collect();- assert_eq!(- user_skills,- vec![SkillMetadata {- name: "ui-skill".to_string(),- description: "from json".to_string(),- short_description: None,- interface: Some(SkillInterface {- display_name: Some("UI Skill".to_string()),- short_description: Some("short desc".to_string()),- icon_small: Some(normalized_skill_dir.join("assets/small-400px.png")),- icon_large: Some(normalized_skill_dir.join("assets/large-logo.svg")),- brand_color: Some("#3B82F6".to_string()),- default_prompt: Some("default prompt".to_string()),- }),- dependencies: None,- policy: None,- path_to_skills_md: normalized(skill_path.as_path()),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn loads_skill_policy_from_yaml() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_skill(&codex_home, "demo", "policy-skill", "from json");- let skill_dir = skill_path.parent().expect("skill dir");-- write_skill_metadata_at(- skill_dir,- r#"-policy:- allow_implicit_invocation: false-"#,- );-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 1);- assert_eq!(- outcome.skills[0].policy,- Some(SkillPolicy {- allow_implicit_invocation: Some(false),- products: vec![],- })- );- assert!(outcome.allowed_skills_for_implicit_invocation().is_empty());-}--#[tokio::test]-async fn empty_skill_policy_defaults_to_allow_implicit_invocation() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_skill(&codex_home, "demo", "policy-empty", "from json");- let skill_dir = skill_path.parent().expect("skill dir");-- write_skill_metadata_at(- skill_dir,- r#"-policy: {}-"#,- );-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 1);- assert_eq!(- outcome.skills[0].policy,- Some(SkillPolicy {- allow_implicit_invocation: None,- products: vec![],- })- );- assert_eq!(- outcome.allowed_skills_for_implicit_invocation(),- outcome.skills- );-}--#[tokio::test]-async fn loads_skill_policy_products_from_yaml() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_skill(&codex_home, "demo", "policy-products", "from yaml");- let skill_dir = skill_path.parent().expect("skill dir");-- write_skill_metadata_at(- skill_dir,- r#"-policy:- products:- - codex- - CHATGPT- - atlas-"#,- );-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 1);- assert_eq!(- outcome.skills[0].policy,- Some(SkillPolicy {- allow_implicit_invocation: None,- products: vec![Product::Codex, Product::Chatgpt, Product::Atlas],- })- );-}--#[tokio::test]-async fn loads_plugin_skill_interface_icons_from_shared_plugin_assets() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("plugins/twilio-developer-kit");- let skill_path = write_skill_at(- &plugin_root.join("skills"),- "twilio-send-message",- "send-message",- "send messages",- );- let skill_dir = skill_path.parent().expect("skill dir");- fs::create_dir_all(plugin_root.join("assets")).unwrap();- fs::write(plugin_root.join("assets/logo.svg"), "<svg/>").unwrap();- write_skill_interface_at(- skill_dir,- r##"-interface:- icon_small: "../../assets/logo.svg"- icon_large: "../../assets/logo.svg"-"##,- );-- let plugin_root_abs = plugin_root.abs();- let outcome = load_skills_from_roots(- [SkillRoot {- path: plugin_root.join("skills").abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(PluginIdentity {- plugin_id: "twilio-developer-kit@test".to_string(),- remote_plugin_id: None,- }),- plugin_namespace: None,- plugin_root: Some(plugin_root_abs.clone()),- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- let expected_icon_path = normalized(&plugin_root.join("assets/logo.svg"));- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "send-message".to_string(),- description: "send messages".to_string(),- short_description: None,- interface: Some(SkillInterface {- display_name: None,- short_description: None,- icon_small: Some(expected_icon_path.clone()),- icon_large: Some(expected_icon_path),- brand_color: None,- default_prompt: None,- }),- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: Some("twilio-developer-kit@test".to_string()),- remote_plugin_id: None,- }]- );-}--#[cfg(unix)]-fn symlink_dir(target: &Path, link: &Path) {- std::os::unix::fs::symlink(target, link).unwrap();-}--#[cfg(unix)]-fn symlink_file(target: &Path, link: &Path) {- std::os::unix::fs::symlink(target, link).unwrap();-}--#[tokio::test]-#[cfg(unix)]-async fn loads_skills_via_symlinked_subdir_for_user_scope() {- let codex_home = tempfile::tempdir().expect("tempdir");- let shared = tempfile::tempdir().expect("tempdir");-- let shared_skill_path = write_skill_at(shared.path(), "demo", "linked-skill", "from link");-- fs::create_dir_all(codex_home.path().join("skills")).unwrap();- symlink_dir(shared.path(), &codex_home.path().join("skills/shared"));-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "linked-skill".to_string(),- description: "from link".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&shared_skill_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );- let canonical_skill_path = normalized(&shared_skill_path);- let discovery_path = outcome- .skill_root_for_path(&canonical_skill_path)- .expect("symlinked skill should retain its discovery root")- .join("shared/demo/SKILL.md");- assert_eq!(- outcome.skill_discovery_path_for_path(&canonical_skill_path),- Some(&discovery_path)- );- let filtered_outcome =- crate::filter_skill_load_outcome_for_product(outcome, Some(Product::Codex));- assert_eq!(- filtered_outcome.skill_discovery_path_for_path(&canonical_skill_path),- Some(&discovery_path)- );-}--// Directory symlinks on Windows can require Developer Mode or administrator privileges.-#[tokio::test]-#[cfg(unix)]-async fn loads_skills_through_visible_alias_to_hidden_directory() {- let root = tempfile::tempdir().expect("tempdir");- let hidden_root = root.path().join(".hidden");- let skill_path = write_skill_at(&hidden_root, "search", "search-skill", "search description");- symlink_dir(&hidden_root, &root.path().join("visible"));-- let outcome = load_user_skills_root(root.path()).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![expected_user_skill(- &skill_path,- "search-skill",- "search description",- )]- );-}--#[tokio::test]-#[cfg(unix)]-async fn ignores_symlinked_skill_file_for_user_scope() {- let codex_home = tempfile::tempdir().expect("tempdir");- let shared = tempfile::tempdir().expect("tempdir");-- let shared_skill_path = write_skill_at(shared.path(), "demo", "linked-file-skill", "from link");-- let skill_dir = codex_home.path().join("skills/demo");- fs::create_dir_all(&skill_dir).unwrap();- symlink_file(&shared_skill_path, &skill_dir.join(SKILLS_FILENAME));-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills, Vec::new());-}--#[tokio::test]-#[cfg(unix)]-async fn does_not_loop_on_symlink_cycle_for_user_scope() {- let codex_home = tempfile::tempdir().expect("tempdir");-- // Create a cycle:- // $CODEX_HOME/skills/cycle/loop -> $CODEX_HOME/skills/cycle- let cycle_dir = codex_home.path().join("skills/cycle");- fs::create_dir_all(&cycle_dir).unwrap();- symlink_dir(&cycle_dir, &cycle_dir.join("loop"));-- let skill_path = write_skill_at(&cycle_dir, "demo", "cycle-skill", "still loads");-- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "cycle-skill".to_string(),- description: "still loads".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,- }]- );-}--#[tokio::test]-#[cfg(unix)]-async fn loads_skills_via_symlinked_subdir_for_admin_scope() {- let admin_root = tempfile::tempdir().expect("tempdir");- let shared = tempfile::tempdir().expect("tempdir");-- let shared_skill_path =- write_skill_at(shared.path(), "demo", "admin-linked-skill", "from link");- fs::create_dir_all(admin_root.path()).unwrap();- symlink_dir(shared.path(), &admin_root.path().join("shared"));-- let outcome = load_skills_from_roots(- [SkillRoot {- path: admin_root.path().abs(),- scope: SkillScope::Admin,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*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: "admin-linked-skill".to_string(),- description: "from link".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&shared_skill_path),- scope: SkillScope::Admin,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-#[cfg(unix)]-async fn loads_skills_via_symlinked_subdir_for_repo_scope() {- let repo_dir = tempfile::tempdir().expect("tempdir");- let shared = tempfile::tempdir().expect("tempdir");-- let linked_skill_path = write_skill_at(shared.path(), "demo", "repo-linked-skill", "from link");- let repo_skills_root = repo_dir- .path()- .join(REPO_ROOT_CONFIG_DIR_NAME)- .join(SKILLS_DIR_NAME);- fs::create_dir_all(&repo_skills_root).unwrap();- symlink_dir(shared.path(), &repo_skills_root.join("shared"));-- let outcome =- load_skills_for_test([local_skill_root(&repo_skills_root, SkillScope::Repo)]).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "repo-linked-skill".to_string(),- description: "from link".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&linked_skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- }]- );- let canonical_skill_path = normalized(&linked_skill_path);- let discovery_path = outcome- .skill_root_for_path(&canonical_skill_path)- .expect("repo skill should retain its discovery root")- .join("shared/demo/SKILL.md");- assert_eq!(- outcome.skill_discovery_path_for_path(&canonical_skill_path),- Some(&discovery_path)- );-}--#[tokio::test]-#[cfg(unix)]-async fn system_scope_ignores_symlinked_subdir() {- let codex_home = tempfile::tempdir().expect("tempdir");- let shared = tempfile::tempdir().expect("tempdir");-- write_skill_at(shared.path(), "demo", "system-linked-skill", "from link");-- let system_root = codex_home.path().join("skills/.system");- fs::create_dir_all(&system_root).unwrap();- symlink_dir(shared.path(), &system_root.join("shared"));-- let outcome = load_skills_from_roots(- [SkillRoot {- path: system_root.abs(),- scope: SkillScope::System,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*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.len(), 0);-}--#[tokio::test]-async fn respects_max_scan_depth_for_user_scope() {- let codex_home = tempfile::tempdir().expect("tempdir");-- let within_depth_path = write_skill(- &codex_home,- "d0/d1/d2/d3/d4/d5",- "within-depth-skill",- "loads",- );- let _too_deep_path = write_skill(- &codex_home,- "d0/d1/d2/d3/d4/d5/d6",- "too-deep-skill",- "should not load",- );-- let skills_root = codex_home.path().join("skills");- let outcome = load_skills_from_roots(- [SkillRoot {- path: skills_root.abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*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: "within-depth-skill".to_string(),- description: "loads".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&within_depth_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-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 outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "demo-skill".to_string(),- description: "does things carefully".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,- }]- );-}--#[tokio::test]-async fn falls_back_to_directory_name_when_skill_name_is_missing() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_raw_skill_at(- &codex_home.path().join("skills"),- "directory-derived",- "description: fallback name",- );- let outcome = load_user_skills_for_test(&codex_home).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "directory-derived".to_string(),- description: "fallback name".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,- }]- );-}--#[tokio::test]-async fn namespaces_plugin_skills_using_provided_namespace() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("plugins/sample");- let skill_path = write_raw_skill_at(- &plugin_root.join("skills"),- "sample-search",- "description: search sample data",- );- fs::create_dir_all(plugin_root.join(".codex-plugin")).unwrap();- fs::write(- plugin_root.join(".codex-plugin/plugin.json"),- r#"{"name":"should-not-be-read"}"#,- )- .unwrap();-- let outcome = load_skills_from_roots(- [SkillRoot {- path: plugin_root.join("skills").abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(PluginIdentity {- plugin_id: "sample@test".to_string(),- remote_plugin_id: None,- }),- plugin_namespace: Some("sample".to_string()),- plugin_root: Some(plugin_root.abs()),- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*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: "sample:sample-search".to_string(),- description: "search sample data".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: Some("sample@test".to_string()),- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn namespaces_nested_plugin_skills_without_namespacing_plain_siblings() {- let root = tempfile::tempdir().expect("tempdir");- let skills_root = root.path().join("skills");- let plain_skill_path =- write_skill_at(&skills_root, "plain", "plain-skill", "plain description");- let plugin_root = skills_root.join("nested-plugin");- write_plugin_manifest(&plugin_root, r#"{"name":"nested"}"#);- let plugin_skill_path = write_skill_at(- &plugin_root.join("skills"),- "search",- "plugin-skill",- "plugin description",- );-- let outcome = load_user_skills_root(&skills_root).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![- expected_user_skill(- &plugin_skill_path,- "nested:plugin-skill",- "plugin description"- ),- expected_user_skill(&plain_skill_path, "plain-skill", "plain description"),- ]- );-}--#[tokio::test]-async fn inherits_plugin_namespace_from_above_scanned_skills_root() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("plugin");- write_plugin_manifest(&plugin_root, r#"{"name":"outer"}"#);- let skills_root = plugin_root.join("skills");- let skill_path = write_skill_at(&skills_root, "search", "search-skill", "search description");-- let outcome = load_user_skills_root(&skills_root).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![expected_user_skill(- &skill_path,- "outer:search-skill",- "search description",- )]- );-}--#[tokio::test]-async fn nearest_valid_nested_plugin_namespace_overrides_outer_namespace() {- let root = tempfile::tempdir().expect("tempdir");- let outer_plugin_root = root.path().join("outer-plugin");- write_plugin_manifest(&outer_plugin_root, r#"{"name":"outer"}"#);- let skills_root = outer_plugin_root.join("skills");- let nested_plugin_root = skills_root.join("nested-plugin");- write_plugin_manifest(&nested_plugin_root, r#"{"name":"nested"}"#);- let skill_path = write_skill_at(- &nested_plugin_root.join("skills"),- "search",- "search-skill",- "search description",- );-- let outcome = load_user_skills_root(&skills_root).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![expected_user_skill(- &skill_path,- "nested:search-skill",- "search description",- )]- );-}--#[tokio::test]-async fn invalid_nested_plugin_manifest_falls_back_to_outer_namespace() {- let root = tempfile::tempdir().expect("tempdir");- let outer_plugin_root = root.path().join("outer-plugin");- write_plugin_manifest(&outer_plugin_root, r#"{"name":"outer"}"#);- let skills_root = outer_plugin_root.join("skills");- let nested_plugin_root = skills_root.join("nested-plugin");- write_plugin_manifest(&nested_plugin_root, "not json");- let skill_path = write_skill_at(- &nested_plugin_root.join("skills"),- "search",- "search-skill",- "search description",- );-- let outcome = load_user_skills_root(&skills_root).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![expected_user_skill(- &skill_path,- "outer:search-skill",- "search description",- )]- );-}--// Directory symlinks on Windows can require Developer Mode or administrator privileges.-#[cfg(unix)]-#[tokio::test]-async fn does_not_inherit_namespace_for_skills_in_symlinked_plain_dir() {- // outer-plugin/- // ├── .codex-plugin/plugin.json- // └── skills/linked-plain -> plain-root/- // plain-root/- // └── search/SKILL.md- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("outer-plugin");- write_plugin_manifest(&plugin_root, r#"{"name":"outer"}"#);- let skills_root = plugin_root.join("skills");- let plain_root = tempfile::tempdir().expect("tempdir");- let skill_path = write_skill_at(- plain_root.path(),- "search",- "plain-skill",- "plain description",- );- fs::create_dir_all(&skills_root).unwrap();- symlink_dir(plain_root.path(), &skills_root.join("linked-plain"));-- let outcome = load_user_skills_root(&skills_root).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![expected_user_skill(- &skill_path,- "plain-skill",- "plain description",- )]- );-}--// Directory symlinks on Windows can require Developer Mode or administrator privileges.-#[cfg(unix)]-#[tokio::test]-async fn keeps_inherited_namespace_when_symlink_target_is_scan_root_ancestor() {- // temp-root/- // └── a/b/c/d/e/f/outer-plugin/- // ├── .codex-plugin/plugin.json- // └── skills/- // ├── root/SKILL.md- // └── link -> temp-root/- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("a/b/c/d/e/f/outer-plugin");- write_plugin_manifest(&plugin_root, r#"{"name":"outer"}"#);- let skills_root = plugin_root.join("skills");- let skill_path = write_skill_at(&skills_root, "root", "root-skill", "root description");- symlink_dir(root.path(), &skills_root.join("link"));-- let outcome = load_user_skills_root(&skills_root).await;-- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![expected_user_skill(- &skill_path,- "outer:root-skill",- "root description",- )]- );-}--#[tokio::test]-async fn plugin_skill_name_length_limit_allows_max_qualified_name() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_name = "p".repeat(MAX_NAME_LEN);- let skill_name = "s".repeat(MAX_NAME_LEN);- let plugin_root = root.path().join("plugins").join(&plugin_name);- let frontmatter = format!("name: {skill_name}\ndescription: search sample data");- let skill_path = write_raw_skill_at(&plugin_root.join("skills"), "sample-search", &frontmatter);- fs::create_dir_all(plugin_root.join(".codex-plugin")).unwrap();- fs::write(- plugin_root.join(".codex-plugin/plugin.json"),- format!(r#"{{"name":"{plugin_name}"}}"#),- )- .unwrap();-- let outcome = load_skills_from_roots(- [SkillRoot {- path: plugin_root.join("skills").abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(PluginIdentity {- plugin_id: "sample@test".to_string(),- remote_plugin_id: None,- }),- plugin_namespace: Some(plugin_name.clone()),- plugin_root: Some(plugin_root.abs()),- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*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: format!("{plugin_name}:{skill_name}"),- description: "search sample data".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: Some("sample@test".to_string()),- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn plugin_skill_name_length_limit_rejects_overlong_qualified_name() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_name = "p".repeat(MAX_NAME_LEN + 1);- let skill_name = "s".repeat(MAX_NAME_LEN);- let plugin_root = root.path().join("plugins").join(&plugin_name);- let frontmatter = format!("name: {skill_name}\ndescription: search sample data");- write_raw_skill_at(&plugin_root.join("skills"), "sample-search", &frontmatter);- fs::create_dir_all(plugin_root.join(".codex-plugin")).unwrap();- fs::write(- plugin_root.join(".codex-plugin/plugin.json"),- format!(r#"{{"name":"{plugin_name}"}}"#),- )- .unwrap();-- let outcome = load_skills_from_roots(- [SkillRoot {- path: plugin_root.join("skills").abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(PluginIdentity {- plugin_id: "sample@test".to_string(),- remote_plugin_id: None,- }),- plugin_namespace: Some(plugin_name.clone()),- plugin_root: Some(plugin_root.abs()),- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;-- assert_eq!(outcome.skills, Vec::new());- assert_eq!(outcome.errors.len(), 1);- assert!(- outcome.errors[0].message.contains("invalid qualified name"),- "expected qualified name length error, got: {:?}",- outcome.errors- );-}--#[tokio::test]-async fn direct_child_discovery_ignores_nested_skills() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("plugin");- let skills_root = plugin_root.join("skills");- let direct = write_skill_at(&skills_root, "direct", "direct", "direct skill");- write_skill_at(&skills_root, "nested/too-deep", "too-deep", "nested skill");-- let outcome = load_skills_from_roots(- [SkillRoot {- path: skills_root.abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(PluginIdentity {- plugin_id: "plugin@test".to_string(),- remote_plugin_id: None,- }),- plugin_namespace: Some("plugin".to_string()),- plugin_root: Some(plugin_root.abs()),- discovery_mode: SkillDiscoveryMode::DirectChildren,- }],- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;-- assert!(outcome.errors.is_empty());- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "plugin:direct".to_string(),- description: "direct skill".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&direct),- scope: SkillScope::User,- plugin_id: Some("plugin@test".to_string()),- remote_plugin_id: None,- }]- );-}--#[cfg(unix)]-#[tokio::test]-async fn direct_child_discovery_skips_skills_resolving_outside_plugin_root() {- let root = tempfile::tempdir().expect("tempdir");- let plugin_root = root.path().join("plugin");- let skills_root = plugin_root.join("skills");- let outside_root = root.path().join("outside");- write_skill_at(&outside_root, "escaped", "escaped", "escaped skill");- fs::create_dir_all(&skills_root).expect("create skills root");- std::os::unix::fs::symlink(outside_root.join("escaped"), skills_root.join("escaped"))- .expect("create skill symlink");-- let outcome = load_skills_from_roots(- [SkillRoot {- path: skills_root.abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: Some(PluginIdentity {- plugin_id: "plugin@test".to_string(),- remote_plugin_id: None,- }),- plugin_namespace: Some("plugin".to_string()),- plugin_root: Some(plugin_root.abs()),- discovery_mode: SkillDiscoveryMode::DirectChildren,- }],- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;-- assert!(outcome.skills.is_empty());-}--#[tokio::test]-async fn loads_short_description_from_metadata() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_dir = codex_home.path().join("skills/demo");- fs::create_dir_all(&skill_dir).unwrap();- let contents = "---\nname: demo-skill\ndescription: long description\nmetadata:\n short-description: short summary\n---\n\n# Body\n";- let skill_path = skill_dir.join(SKILLS_FILENAME);- fs::write(&skill_path, contents).unwrap();-- let outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "demo-skill".to_string(),- description: "long description".to_string(),- short_description: Some("short summary".to_string()),- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn loads_unquoted_description_containing_colon_space() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_raw_skill_at(- &codex_home.path().join("skills"),- "colon-description",- "name: colon-description\ndescription: AWS deployment patterns: ECS Fargate, Lambda, and S3",- );-- let outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "colon-description".to_string(),- description: "AWS deployment patterns: ECS Fargate, Lambda, and S3".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,- }]- );-}--#[tokio::test]-async fn loads_unquoted_short_description_containing_colon_space_and_apostrophe() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_raw_skill_at(- &codex_home.path().join("skills"),- "colon-short-description",- "name: colon-short-description\ndescription: long description\nmetadata:\n short-description: What's included: builds and tests",- );-- let outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "colon-short-description".to_string(),- description: "long description".to_string(),- short_description: Some("What's included: builds and tests".to_string()),- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- }]- );-}--#[tokio::test]-async fn loads_unrecognized_frontmatter_fields_that_need_quotes() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_raw_skill_at(- &codex_home.path().join("skills"),- "repaired-unknown-fields",- "name: repaired-unknown-fields\ndescription: valid description\nargument-hint: <duration: e.g. 7d, 2w>\ntags: [next,@supabase/ssr]",- );-- let outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "repaired-unknown-fields".to_string(),- description: "valid description".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,- }]- );-}--#[tokio::test]-async fn preserves_block_scalar_body_while_repairing_other_fields() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_path = write_raw_skill_at(- &codex_home.path().join("skills"),- "block-description-with-repair",- "name: block-description-with-repair\ndescription: |-\n Build for AWS: ECS\nargument-hint: <duration: e.g. 7d>",- );-- let outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "block-description-with-repair".to_string(),- description: "Build for AWS: ECS".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,- }]- );-}--#[tokio::test]-async fn preserves_overlong_short_descriptions() {- let codex_home = tempfile::tempdir().expect("tempdir");- let skill_dir = codex_home.path().join("skills/demo");- fs::create_dir_all(&skill_dir).unwrap();- let too_long = "x".repeat(MAX_DESCRIPTION_LEN + 1);- let contents = format!(- "---\nname: demo-skill\ndescription: long description\nmetadata:\n short-description: {too_long}\n---\n\n# Body\n"- );- fs::write(skill_dir.join(SKILLS_FILENAME), contents).unwrap();-- let outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 1);- assert_eq!(outcome.skills[0].short_description, Some(too_long));-}--#[tokio::test]-async fn skips_hidden_and_invalid() {- let codex_home = tempfile::tempdir().expect("tempdir");- let hidden_dir = codex_home.path().join("skills/.hidden");- fs::create_dir_all(&hidden_dir).unwrap();- fs::write(- hidden_dir.join(SKILLS_FILENAME),- "---\nname: hidden\ndescription: hidden\n---\n",- )- .unwrap();-- // Invalid because missing closing frontmatter.- let invalid_dir = codex_home.path().join("skills/invalid");- fs::create_dir_all(&invalid_dir).unwrap();- fs::write(invalid_dir.join(SKILLS_FILENAME), "---\nname: bad").unwrap();-- let outcome = load_user_skills_for_test(&codex_home).await;- assert_eq!(outcome.skills.len(), 0);- assert_eq!(outcome.errors.len(), 1);- assert!(- outcome.errors[0]- .message- .contains("missing YAML frontmatter"),- "expected frontmatter error"- );-}--#[tokio::test]-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 outcome = load_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 1);-- 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_user_skills_for_test(&codex_home).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(outcome.skills.len(), 2);- let too_long_skill = outcome- .skills- .iter()- .find(|skill| skill.name == "too-long")- .expect("too-long skill");- assert_eq!(too_long_skill.description, too_long_desc);-}--#[tokio::test]-async fn loads_skills_from_repo_scoped_root() {- let repo_dir = tempfile::tempdir().expect("tempdir");-- 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 outcome = load_skills_for_test([local_skill_root(&skills_root, SkillScope::Repo)]).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 loads_skills_from_multiple_repo_scoped_roots() {- let repo_dir = tempfile::tempdir().expect("tempdir");-- 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: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![- SkillMetadata {- name: "nested-skill".to_string(),- description: "from nested".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&nested_skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- },- SkillMetadata {- name: "root-skill".to_string(),- description: "from root".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&root_skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- },- ]- );-}-#[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;-- let temp = tempfile::tempdir().expect("tempdir");- let roots = (0..ROOT_COUNT)- .map(|index| temp.path().join(format!("root-{index}")))- .collect::<Vec<_>>();- for root in &roots {- fs::create_dir_all(root).expect("create root");- }- let first_skill = roots[0].join("broken/SKILL.md");- let second_skill = roots[1].join("broken/SKILL.md");- for (path, contents) in [- (&first_skill, "missing frontmatter"),- (&second_skill, "also missing frontmatter"),- ] {- fs::create_dir_all(path.parent().expect("skill parent")).expect("create skill directory");- fs::write(path, contents).expect("write skill");- }-- let blocked_walk_root = PathUri::from_abs_path(&roots[0].abs());- let file_system = Arc::new(BlockingRepoSkillRootFileSystem {- inner: Arc::clone(&LOCAL_FS),- blocked_walk_root: Some(blocked_walk_root),- blocked_walk_gate: Semaphore::new(/*permits*/ 0),- walks_started: AtomicUsize::new(/*v*/ 0),- walk_started: Notify::new(),- });- let root_file_system: Arc<dyn ExecutorFileSystem> = file_system.clone();- let skill_roots = roots- .iter()- .enumerate()- .map(|(index, root)| SkillRoot {- path: root.abs(),- scope: if index == 0 {- SkillScope::Repo- } else {- SkillScope::User- },- file_system: Arc::clone(&root_file_system),- plugin_identity: None,- plugin_namespace: Some("test".to_string()),- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- })- .collect::<Vec<_>>();- let root_scan_slots = Semaphore::new(MAX_CONCURRENT_ROOT_SCANS);- let load = tokio::spawn(async move {- crate::root_loader::load_and_merge_skill_roots(- skill_roots,- /*plugin_skill_snapshots*/ None,- &root_scan_slots,- )- .await- });-- tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), async {- loop {- let started = file_system.walk_started.notified();- if file_system.walks_started.load(Ordering::Acquire) == ROOT_COUNT {- break;- }- started.await;- }- })- .await- .expect("all skill-root walks should start despite the blocked first root");- file_system.blocked_walk_gate.add_permits(/*n*/ 1);- let outcome = load.await.expect("skill-root load should finish");-- assert_eq!(outcome.skills, Vec::new());- assert_eq!(- outcome.errors,- vec![- SkillError {- path: canonicalize_path(first_skill)- .expect("canonical first skill")- .abs(),- message: "missing YAML frontmatter delimited by ---".to_string(),- },- SkillError {- path: canonicalize_path(second_skill)- .expect("canonical second skill")- .abs(),- message: "missing YAML frontmatter delimited by ---".to_string(),- },- ]- );-}--#[tokio::test]-async fn skill_root_scans_wait_for_shared_capacity() {- let temp = tempfile::tempdir().expect("tempdir");- let root = temp.path().join("root");- fs::create_dir_all(&root).expect("create root");- let root_scan_slots = Semaphore::new(MAX_CONCURRENT_ROOT_SCANS);- let held_slots = root_scan_slots- .try_acquire_many(- u32::try_from(MAX_CONCURRENT_ROOT_SCANS).expect("root scan limit should fit in u32"),- )- .expect("root scan slots should be available");- let load = crate::root_loader::load_and_merge_skill_roots(- [SkillRoot {- path: root.abs(),- scope: SkillScope::Repo,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: Some("test".to_string()),- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- }],- /*plugin_skill_snapshots*/ None,- &root_scan_slots,- );- tokio::pin!(load);-- assert!(futures::poll!(load.as_mut()).is_pending());- drop(held_slots);- let outcome = load.await;-- assert_eq!(outcome.skills, Vec::new());- assert_eq!(outcome.errors, Vec::new());-}--#[tokio::test]-async fn deduplicates_by_path_preferring_first_root() {- let root = tempfile::tempdir().expect("tempdir");-- let skill_path = write_skill_at(root.path(), "dupe", "dupe-skill", "from repo");-- let outcome = load_skills_from_roots(- [- SkillRoot {- path: root.path().abs(),- scope: SkillScope::Repo,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- },- SkillRoot {- path: root.path().abs(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: SkillDiscoveryMode::Recursive,- },- ],- /*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: "dupe-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,- }]- );-}--#[cfg(unix)]-#[tokio::test]-async fn deduplicated_symlinked_skill_preserves_first_discovery_path() {- let source_root = tempfile::tempdir().expect("source tempdir");- let first_root = tempfile::tempdir().expect("first tempdir");- let second_root = tempfile::tempdir().expect("second tempdir");- let skill_path = write_skill_at(source_root.path(), "demo", "demo", "shared skill");- symlink_dir(- &source_root.path().join("demo"),- &first_root.path().join("first-link"),- );- symlink_dir(- &source_root.path().join("demo"),- &second_root.path().join("second-link"),- );-- let outcome = load_skills_for_test([- local_skill_root(first_root.path(), SkillScope::Repo),- local_skill_root(second_root.path(), SkillScope::User),- ])- .await;- let canonical_skill_path = normalized(&skill_path);- let expected_root = normalized(first_root.path());- let expected_discovery_path = expected_root.join("first-link/SKILL.md");-- assert_eq!(outcome.skills.len(), 1);- assert_eq!(- (- outcome.skill_root_for_path(&canonical_skill_path),- outcome.skill_discovery_path_for_path(&canonical_skill_path),- ),- (Some(&expected_root), Some(&expected_discovery_path))- );-}--#[tokio::test]-async fn keeps_duplicate_names_from_repo_and_user() {- let codex_home = tempfile::tempdir().expect("tempdir");- let repo_dir = tempfile::tempdir().expect("tempdir");-- let user_skill_path = write_skill(&codex_home, "user", "dupe-skill", "from user");- 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([- 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: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![- SkillMetadata {- name: "dupe-skill".to_string(),- description: "from repo".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&repo_skill_path),- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- },- SkillMetadata {- name: "dupe-skill".to_string(),- description: "from user".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&user_skill_path),- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- },- ]- );-}--#[tokio::test]-async fn keeps_duplicate_names_from_nested_codex_dirs() {- let repo_dir = tempfile::tempdir().expect("tempdir");-- 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(),- "unexpected errors: {:?}",- outcome.errors- );- let root_path = normalized(&root_skill_path);- let nested_path = normalized(&nested_skill_path);- let (first_path, second_path, first_description, second_description) =- if root_path <= nested_path {- (root_path, nested_path, "from root", "from nested")- } else {- (nested_path, root_path, "from nested", "from root")- };- assert_eq!(- outcome.skills,- vec![- SkillMetadata {- name: "dupe-skill".to_string(),- description: first_description.to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: first_path,- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- },- SkillMetadata {- name: "dupe-skill".to_string(),- description: second_description.to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: second_path,- scope: SkillScope::Repo,- plugin_id: None,- remote_plugin_id: None,- },- ]- );-}-#[tokio::test]-async fn loads_skills_from_system_scoped_root() {- let codex_home = 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 outcome = load_skills_for_test([local_skill_root(&system_root, SkillScope::System)]).await;- assert!(- outcome.errors.is_empty(),- "unexpected errors: {:?}",- outcome.errors- );- assert_eq!(- outcome.skills,- vec![SkillMetadata {- name: "system-skill".to_string(),- description: "from system".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: normalized(&skill_path),- scope: SkillScope::System,- plugin_id: None,- remote_plugin_id: None,- }]- );-}diff --git a/codex-rs/core-skills/src/model.rs b/codex-rs/core-skills/src/model.rsindex c9d2677c2e..a26916da27 100644--- a/codex-rs/core-skills/src/model.rs+++ b/codex-rs/core-skills/src/model.rs@@ -6,7 +6,6 @@ use std::sync::Arc;use codex_exec_server::ExecutorFileSystem;use codex_exec_server::LOCAL_FS;-use codex_protocol::protocol::Product;pub use codex_skills::SkillDependencies;pub use codex_skills::SkillError;pub use codex_skills::SkillInterface;@@ -120,14 +119,6 @@ impl SkillLoadOutcome {.get(&skill.path_to_skills_md)}- /// Builds the legacy aggregate from independently loaded roots.- ///- /// This is a temporary migration boundary while host root loading moves to the skills- /// extension. It deliberately reuses the existing merge, precedence, and deduplication logic.- pub fn from_root_snapshots(snapshots: Vec<crate::loader::SkillRootSnapshot>) -> Self {- crate::root_loader::merge_skill_root_snapshots(snapshots)- }-/// Reads one loaded skill through the filesystem that discovered it.pub async fn read_skill_text(&self, skill: &SkillMetadata) -> io::Result<String> {let fs = self@@ -181,16 +172,6 @@ impl SkillFileSystemsByPath {fn get(&self, path: &AbsolutePathBuf) -> Option<Arc<dyn ExecutorFileSystem>> {self.values.get(path).map(Arc::clone)}-- fn retain_paths(&mut self, paths: &HashSet<AbsolutePathBuf>) {- self.values = Arc::new(- self.values- .iter()- .filter(|(path, _)| paths.contains(*path))- .map(|(path, fs)| (path.clone(), Arc::clone(fs)))- .collect(),- );- }}impl fmt::Debug for SkillFileSystemsByPath {@@ -200,61 +181,3 @@ impl fmt::Debug for SkillFileSystemsByPath {.finish()}}--pub fn filter_skill_load_outcome_for_product(- mut outcome: SkillLoadOutcome,- restriction_product: Option<Product>,-) -> SkillLoadOutcome {- outcome- .skills- .retain(|skill| skill.matches_product_restriction_for_product(restriction_product));- let retained_paths: HashSet<AbsolutePathBuf> = outcome- .skills- .iter()- .map(|skill| skill.path_to_skills_md.clone())- .collect();- outcome- .file_systems_by_skill_path- .retain_paths(&retained_paths);- outcome.skill_root_by_path = Arc::new(- outcome- .skill_root_by_path- .iter()- .filter(|(path, _)| retained_paths.contains(*path))- .map(|(path, root)| (path.clone(), root.clone()))- .collect(),- );- outcome.skill_discovery_path_by_path = Arc::new(- outcome- .skill_discovery_path_by_path- .iter()- .filter(|(path, _)| retained_paths.contains(*path))- .map(|(path, discovery_path)| (path.clone(), discovery_path.clone()))- .collect(),- );- outcome- .agent_plugin_skill_paths- .retain(|path| retained_paths.contains(path));- let retained_roots: HashSet<AbsolutePathBuf> =- outcome.skill_root_by_path.values().cloned().collect();- outcome- .skill_roots- .retain(|root| retained_roots.contains(root));- outcome.implicit_skills_by_scripts_dir = Arc::new(- outcome- .implicit_skills_by_scripts_dir- .iter()- .filter(|(_, skill)| skill.matches_product_restriction_for_product(restriction_product))- .map(|(path, skill)| (path.clone(), skill.clone()))- .collect(),- );- outcome.implicit_skills_by_doc_path = Arc::new(- outcome- .implicit_skills_by_doc_path- .iter()- .filter(|(_, skill)| skill.matches_product_restriction_for_product(restriction_product))- .map(|(path, skill)| (path.clone(), skill.clone()))- .collect(),- );- outcome-}diff --git a/codex-rs/core-skills/src/root_loader.rs b/codex-rs/core-skills/src/root_loader.rsdeleted file mode 100644index 5ba4206565..0000000000--- a/codex-rs/core-skills/src/root_loader.rs+++ /dev/null@@ -1,221 +0,0 @@-use std::collections::HashMap;-use std::collections::HashSet;-use std::fmt;-use std::hash::Hash;-use std::hash::Hasher;-use std::sync::Arc;-use std::sync::Mutex;--use codex_utils_plugins::PluginSkillRoot;-use futures::StreamExt;-use tokio::sync::Semaphore;--use crate::SkillLoadOutcome;-use crate::loader::MAX_CONCURRENT_ROOT_SCANS;-use crate::loader::SkillRoot;-use crate::loader::SkillRootSnapshot;-use crate::loader::load_skill_root;-use crate::model::SkillFileSystemsByPath;--/// Parsed plugin skill-root snapshots produced by one plugin load.-///-/// Clones share the same snapshots. The plugins manager stores them with the corresponding loaded-/// plugins and passes a clone to skill loading as an optional preload.-#[derive(Clone)]-pub struct PluginSkillSnapshots {- snapshots_by_root: Arc<Mutex<HashMap<PluginSkillRoot, SkillRootSnapshot>>>,-}--impl PluginSkillSnapshots {- /// Creates an empty snapshot collection for a plugin load to populate.- pub fn for_plugin_load() -> Self {- Self {- snapshots_by_root: Arc::new(Mutex::new(HashMap::new())),- }- }-}--impl PartialEq for PluginSkillSnapshots {- fn eq(&self, other: &Self) -> bool {- Arc::ptr_eq(&self.snapshots_by_root, &other.snapshots_by_root)- }-}--impl Eq for PluginSkillSnapshots {}--impl Hash for PluginSkillSnapshots {- fn hash<H: Hasher>(&self, state: &mut H) {- Arc::as_ptr(&self.snapshots_by_root).hash(state);- }-}--impl fmt::Debug for PluginSkillSnapshots {- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {- f.debug_struct("PluginSkillSnapshots")- .finish_non_exhaustive()- }-}--pub(crate) async fn load_and_merge_skill_roots<I>(- roots: I,- plugin_skill_snapshots: Option<&PluginSkillSnapshots>,- root_scan_slots: &Semaphore,-) -> SkillLoadOutcome-where- I: IntoIterator<Item = SkillRoot>,-{- let mut indexed_root_snapshots = futures::stream::iter(roots.into_iter().enumerate())- .map(|(root_index, root)| async move {- // Bound root scans across all concurrent loads sharing this pool.- let _root_scan_slot = root_scan_slots- .acquire()- .await- .unwrap_or_else(|_| unreachable!());- let snapshot = load_skill_root_snapshot(root, plugin_skill_snapshots).await;- (root_index, snapshot)- })- // Keep each load's scan queue bounded while avoiding head-of-line blocking.- .buffer_unordered(MAX_CONCURRENT_ROOT_SCANS)- .collect::<Vec<_>>()- .await;- // Keep every scan slot productive, then restore root precedence for deterministic merging.- indexed_root_snapshots.sort_unstable_by_key(|(root_index, _)| *root_index);- let root_snapshots = indexed_root_snapshots- .into_iter()- .map(|(_, snapshot)| snapshot)- .collect();-- merge_skill_root_snapshots(root_snapshots)-}--/// Loads one root while preserving the existing plugin-loader snapshot reuse.-///-/// This is a temporary migration boundary for callers that load non-plugin roots elsewhere but-/// still need plugin roots to use the legacy preload cache.-pub async fn load_skill_root_snapshot(- root: SkillRoot,- plugin_skill_snapshots: Option<&PluginSkillSnapshots>,-) -> SkillRootSnapshot {- let cache_key = match (- root.plugin_identity.clone(),- root.plugin_namespace.clone(),- root.plugin_root.clone(),- ) {- (Some(plugin_identity), Some(plugin_namespace), Some(plugin_root)) => {- Some(PluginSkillRoot {- path: root.path.clone(),- plugin_identity,- plugin_namespace,- plugin_root,- discovery_mode: root.discovery_mode,- })- }- _ => None,- };- let cached_snapshot = cache_key.as_ref().and_then(|cache_key| {- let plugin_skill_snapshots = plugin_skill_snapshots?;- plugin_skill_snapshots- .snapshots_by_root- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .get(cache_key)- .cloned()- });-- match cached_snapshot {- Some(snapshot) => snapshot,- None => {- let snapshot = load_skill_root(root).await;- if let Some(plugin_skill_snapshots) = plugin_skill_snapshots- && let Some(cache_key) = cache_key- {- plugin_skill_snapshots- .snapshots_by_root- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .insert(cache_key, snapshot.clone());- }- snapshot- }- }-}--pub(crate) fn merge_skill_root_snapshots(snapshots: Vec<SkillRootSnapshot>) -> SkillLoadOutcome {- fn scope_rank(scope: codex_protocol::protocol::SkillScope) -> u8 {- use codex_protocol::protocol::SkillScope;-- // Higher-priority scopes first (matches root scan order for dedupe).- match scope {- SkillScope::Repo => 0,- SkillScope::User => 1,- SkillScope::System => 2,- SkillScope::Admin => 3,- }- }-- let mut outcome = SkillLoadOutcome::default();- let mut skill_roots = Vec::new();- let mut skill_root_by_path = HashMap::new();- let mut skill_discovery_path_by_path = HashMap::new();- let mut file_systems_by_skill_path = HashMap::new();-- for snapshot in snapshots {- let SkillRootSnapshot {- root,- is_agent_plugin,- skills,- skill_discovery_path_by_path: discovery_paths,- errors,- file_system,- } = snapshot;- if !skills.is_empty() && !skill_roots.contains(&root) {- skill_roots.push(root.clone());- }- for skill in &skills {- let path = skill.path_to_skills_md.clone();- if !skill_root_by_path.contains_key(&path) {- skill_root_by_path.insert(path.clone(), root.clone());- if let Some(discovery_path) = discovery_paths.get(&path) {- skill_discovery_path_by_path.insert(path.clone(), discovery_path.clone());- }- file_systems_by_skill_path.insert(path.clone(), Arc::clone(&file_system));- if is_agent_plugin {- outcome.agent_plugin_skill_paths.insert(path);- }- }- }- outcome.skills.extend(skills);- outcome.errors.extend(errors);- }-- let mut seen = HashSet::new();- outcome- .skills- .retain(|skill| seen.insert(skill.path_to_skills_md.clone()));- let retained_skill_paths = outcome- .skills- .iter()- .map(|skill| skill.path_to_skills_md.clone())- .collect::<HashSet<_>>();- skill_root_by_path.retain(|path, _| retained_skill_paths.contains(path));- skill_discovery_path_by_path.retain(|path, _| retained_skill_paths.contains(path));- let used_roots = skill_root_by_path.values().cloned().collect::<HashSet<_>>();- skill_roots.retain(|root| used_roots.contains(root));- file_systems_by_skill_path.retain(|path, _| retained_skill_paths.contains(path));- outcome- .agent_plugin_skill_paths- .retain(|path| retained_skill_paths.contains(path));- outcome.skill_roots = skill_roots;- outcome.skill_root_by_path = Arc::new(skill_root_by_path);- outcome.skill_discovery_path_by_path = Arc::new(skill_discovery_path_by_path);- outcome.file_systems_by_skill_path = SkillFileSystemsByPath::new(file_systems_by_skill_path);-- outcome.skills.sort_by(|a, b| {- scope_rank(a.scope)- .cmp(&scope_rank(b.scope))- .then_with(|| a.name.cmp(&b.name))- .then_with(|| a.path_to_skills_md.cmp(&b.path_to_skills_md))- });-- outcome-}diff --git a/codex-rs/core-skills/tests/environment_loader.rs b/codex-rs/core-skills/tests/environment_loader.rsdeleted file mode 100644index 53cbac4abd..0000000000--- a/codex-rs/core-skills/tests/environment_loader.rs+++ /dev/null@@ -1,294 +0,0 @@-#![cfg(unix)]--use std::fs;-use std::sync::Mutex;-use std::sync::atomic::AtomicUsize;-use std::sync::atomic::Ordering;--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_utils_path_uri::PathUri;-use pretty_assertions::assert_eq;-use tempfile::tempdir;--struct RecordingFileSystem<'a> {- inner: &'a dyn ExecutorFileSystem,- read_files: Mutex<Vec<PathUri>>,- metadata_files: Mutex<Vec<PathUri>>,- walks: AtomicUsize,-}--#[derive(Debug, PartialEq, Eq)]-struct FileSystemCalls {- walks: usize,- read_files: Vec<PathUri>,- metadata_files: Vec<PathUri>,-}--impl<'a> RecordingFileSystem<'a> {- fn new(inner: &'a dyn ExecutorFileSystem) -> Self {- Self {- inner,- read_files: Mutex::new(Vec::new()),- metadata_files: Mutex::new(Vec::new()),- walks: AtomicUsize::new(0),- }- }-- fn calls(&self) -> FileSystemCalls {- let mut read_files = self- .read_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .clone();- read_files.sort_by_key(ToString::to_string);- let mut metadata_files = self- .metadata_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .clone();- metadata_files.sort_by_key(ToString::to_string);- FileSystemCalls {- walks: self.walks.load(Ordering::Relaxed),- read_files,- metadata_files,- }- }-}--impl ExecutorFileSystem for RecordingFileSystem<'_> {- 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.read_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .push(path.clone());- 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> {- self.metadata_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .push(path.clone());- self.inner.get_metadata(path, sandbox)- }-- 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.walks.fetch_add(1, Ordering::Relaxed);- 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)- }-}--#[cfg(unix)]-#[tokio::test]-async fn host_loading_reuses_walk_inventory_for_symlinked_skill_pack() {- use std::os::unix::fs::symlink;- use std::sync::Arc;-- use codex_core_skills::SkillMetadata;- use codex_core_skills::SkillPolicy;- 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_protocol::protocol::SkillScope;- use codex_utils_absolute_path::test_support::PathBufExt;-- let root = tempdir().expect("tempdir");- let shared_plugin_root = tempdir().expect("tempdir");- let manifest_path = shared_plugin_root.path().join(".codex-plugin/plugin.json");- fs::create_dir_all(manifest_path.parent().expect("manifest parent")).expect("manifest dir");- fs::write(&manifest_path, r#"{"name":"linked"}"#).expect("manifest");-- let skills_root = shared_plugin_root.path().join("skills");- for name in ["first", "second"] {- let skill_path = skills_root.join(name).join("SKILL.md");- fs::create_dir_all(skill_path.parent().expect("skill parent")).expect("skill dir");- fs::write(- &skill_path,- format!("---\nname: {name}\ndescription: {name} skill.\n---\n"),- )- .expect("skill");- }- let metadata_path = skills_root.join("first/agents/openai.yaml");- fs::create_dir_all(metadata_path.parent().expect("metadata parent")).expect("metadata dir");- fs::write(- &metadata_path,- "policy:\n allow_implicit_invocation: false\n",- )- .expect("metadata");-- let host_root = root.path().join("skills");- fs::create_dir_all(&host_root).expect("host skills dir");- let linked_root = host_root.join("linked-plugin");- symlink(&skills_root, &linked_root).expect("skill pack symlink");-- let recording = Arc::new(RecordingFileSystem::new(LOCAL_FS.as_ref()));- let file_system: Arc<dyn ExecutorFileSystem> = recording.clone();- let future = load_skills_from_roots(- [SkillRoot {- path: host_root.abs(),- scope: SkillScope::User,- file_system,- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: codex_utils_plugins::SkillDiscoveryMode::Recursive,- }],- /*plugin_skill_snapshots*/ None,- Arc::new(tokio::sync::Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- );- fn assert_send<T: Send>(_: &T) {}- assert_send(&future);- let outcome = future.await;-- assert_eq!(outcome.errors, Vec::new());- let first_skill_path = dunce::canonicalize(skills_root.join("first/SKILL.md"))- .unwrap()- .abs();- let second_skill_path = dunce::canonicalize(skills_root.join("second/SKILL.md"))- .unwrap()- .abs();- assert_eq!(- outcome.skills,- vec![- SkillMetadata {- name: "linked:first".to_string(),- description: "first skill.".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: Some(SkillPolicy {- allow_implicit_invocation: Some(false),- products: Vec::new(),- }),- path_to_skills_md: first_skill_path,- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- },- SkillMetadata {- name: "linked:second".to_string(),- description: "second skill.".to_string(),- short_description: None,- interface: None,- dependencies: None,- policy: None,- path_to_skills_md: second_skill_path,- scope: SkillScope::User,- plugin_id: None,- remote_plugin_id: None,- },- ]- );-- let calls = recording.calls();- assert_eq!(calls.walks, 1);- let linked_root = PathUri::from_host_native_path(linked_root).unwrap();- assert!(- calls- .read_files- .iter()- .all(|path| !path.starts_with(&linked_root))- );- assert!(- calls- .metadata_files- .iter()- .all(|path| path.basename().as_deref() != Some("openai.yaml"))- );- let manifest_uri =- PathUri::from_host_native_path(dunce::canonicalize(manifest_path).unwrap()).unwrap();- assert_eq!(- calls- .metadata_files- .iter()- .filter(|path| **path == manifest_uri)- .count(),- 1- );-}diff --git a/codex-rs/core/src/skills.rs b/codex-rs/core/src/skills.rsindex 4a71209e5b..8fef509fd8 100644--- a/codex-rs/core/src/skills.rs+++ b/codex-rs/core/src/skills.rs@@ -18,11 +18,9 @@ pub use codex_core_skills::SkillLoadOutcome;pub use codex_core_skills::build_skill_name_counts;pub use codex_core_skills::config_rules;pub use codex_core_skills::detect_implicit_skill_invocation_for_command;-pub use codex_core_skills::filter_skill_load_outcome_for_product;pub use codex_core_skills::injection;pub use codex_core_skills::injection::SkillInjections;pub use codex_core_skills::injection::build_skill_injections;-pub use codex_core_skills::loader;pub use codex_core_skills::model;pub use codex_core_skills::remote;pub use codex_skills::SkillMetadata;diff --git a/codex-rs/ext/skills/src/host_roots.rs b/codex-rs/ext/skills/src/host_roots.rsindex 1bb0b21658..ae9367cc4e 100644--- a/codex-rs/ext/skills/src/host_roots.rs+++ b/codex-rs/ext/skills/src/host_roots.rs@@ -7,7 +7,6 @@ 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;@@ -15,7 +14,6 @@ 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;@@ -32,7 +30,7 @@ pub(crate) async fn resolve_skill_roots(cwd: &AbsolutePathBuf,plugin_skill_roots: Vec<PluginSkillRoot>,extra_skill_roots: Vec<AbsolutePathBuf>,-) -> Vec<SkillRoot> {+) -> Vec<HostSkillRoot> {let home_dir =home_dir().and_then(|path| AbsolutePathBuf::from_absolute_path_checked(path).ok());resolve_skill_roots_with_home_dir(@@ -53,33 +51,20 @@ async fn resolve_skill_roots_with_home_dir(home_dir: Option<&AbsolutePathBuf>,plugin_skill_roots: Vec<PluginSkillRoot>,extra_skill_roots: Vec<AbsolutePathBuf>,-) -> Vec<SkillRoot> {+) -> Vec<HostSkillRoot> {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_from_layer_stack(config_layer_stack, home_dir, repository_file_system.clone());roots.extend(- extra_skill_roots+ plugin_skill_roots.into_iter()- .map(|path| local_root(path, SkillScope::User))- .map(host_root_to_skill_root),+ .map(|root| HostSkillRoot::plugin(root, Arc::clone(&LOCAL_FS))),);roots.extend(- repo_agents_skill_roots(repository_file_system, config_layer_stack, cwd)- .await+ extra_skill_roots.into_iter()- .map(host_root_to_skill_root),+ .map(|path| local_root(path, SkillScope::User)),);+ roots.extend(repo_agents_skill_roots(repository_file_system, config_layer_stack, cwd).await);dedupe_skill_roots_by_path(&mut roots);roots}@@ -147,18 +132,6 @@ fn local_root(path: AbsolutePathBuf, scope: SkillScope) -> HostSkillRoot {HostSkillRoot::host(path, scope, Arc::clone(&LOCAL_FS))}-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,@@ -285,7 +258,7 @@ fn dirs_between_project_root_and_cwd(directories}-fn dedupe_skill_roots_by_path(roots: &mut Vec<SkillRoot>) {+fn dedupe_skill_roots_by_path(roots: &mut Vec<HostSkillRoot>) {let mut seen = HashSet::new();roots.retain(|root| seen.insert(root.path.clone()));}diff --git a/codex-rs/ext/skills/src/host_roots_tests.rs b/codex-rs/ext/skills/src/host_roots_tests.rsindex b31072ae69..76b91e0ef7 100644--- a/codex-rs/ext/skills/src/host_roots_tests.rs+++ b/codex-rs/ext/skills/src/host_roots_tests.rs@@ -8,8 +8,6 @@ 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;@@ -36,6 +34,8 @@ use tokio::sync::Semaphore;use super::repo_agents_skill_roots;use super::resolve_skill_roots_with_home_dir;use super::roots_from_layer_stack;+use crate::loader::MAX_CONCURRENT_ROOT_SCANS;+use crate::loader::load_and_merge_host_skill_roots;struct BlockingMetadataFileSystem {inner: Arc<dyn ExecutorFileSystem>,@@ -317,10 +317,10 @@ async fn plugin_roots_preserve_plugin_resolution_metadata() {(root.path.clone(),root.scope,- root.plugin_identity.clone(),- root.plugin_namespace.clone(),- root.plugin_root.clone(),- root.discovery_mode,+ root.plugin_identity().cloned(),+ root.plugin_namespace().map(str::to_string),+ root.plugin_root().cloned(),+ root.discovery_mode(),),(skills_root,@@ -357,10 +357,10 @@ async fn unique_extra_root_loads_as_recursive_user_root() {(root.path.clone(),root.scope,- root.plugin_identity.clone(),- root.plugin_namespace.clone(),- root.plugin_root.clone(),- root.discovery_mode,+ root.plugin_identity().cloned(),+ root.plugin_namespace().map(str::to_string),+ root.plugin_root().cloned(),+ root.discovery_mode(),),(extra_root,@@ -373,10 +373,11 @@ async fn unique_extra_root_loads_as_recursive_user_root() {);assert!(Arc::ptr_eq(&root.file_system, &LOCAL_FS));- let outcome = load_skills_from_roots(+ let outcome = load_and_merge_host_skill_roots(roots,+ &Semaphore::new(MAX_CONCURRENT_ROOT_SCANS),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),).await;@@ -455,10 +456,11 @@ async fn resolved_project_layer_loads_skill_without_git_marker() {Vec::new(),).await;- let outcome = load_skills_from_roots(+ let outcome = load_and_merge_host_skill_roots(roots,+ &Semaphore::new(MAX_CONCURRENT_ROOT_SCANS),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),).await;@@ -491,10 +493,11 @@ async fn resolved_project_layer_loads_skill_when_cwd_is_file() {Vec::new(),).await;- let outcome = load_skills_from_roots(+ let outcome = load_and_merge_host_skill_roots(roots,+ &Semaphore::new(MAX_CONCURRENT_ROOT_SCANS),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),).await;@@ -645,10 +648,11 @@ async fn resolved_config_and_repo_roots_preserve_order_and_dedupe_paths_not_name).await;assert_eq!(roots.len(), 8);- let outcome = load_skills_from_roots(+ let outcome = load_and_merge_host_skill_roots(roots,+ &Semaphore::new(MAX_CONCURRENT_ROOT_SCANS),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),).await;assert!(outcome.errors.is_empty());diff --git a/codex-rs/ext/skills/src/host_service.rs b/codex-rs/ext/skills/src/host_service.rsindex ab375a1ad3..0a33736bc1 100644--- a/codex-rs/ext/skills/src/host_service.rs+++ b/codex-rs/ext/skills/src/host_service.rs@@ -24,8 +24,6 @@ use codex_core_skills::SkillLoadOutcome;use codex_core_skills::config_rules::SkillConfigRules;use codex_core_skills::config_rules::resolve_disabled_skill_paths;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_skills::LoadedSkills;use codex_skills::SkillLoadFuture;use codex_skills::SkillRootLoadRequest;@@ -36,6 +34,7 @@ use codex_skills::install_system_skills;use crate::HostSkillsSnapshot;use crate::host_roots::resolve_skill_roots;use crate::loader::HostSkillRoot;+use crate::loader::MAX_CONCURRENT_ROOT_SCANS;use crate::loader::load_and_merge_host_skill_roots;#[derive(Debug, Clone)]@@ -165,7 +164,7 @@ impl HostSkillsService {&self,input: &HostSkillsLoadInput,fs: Option<Arc<dyn ExecutorFileSystem>>,- ) -> Vec<SkillRoot> {+ ) -> Vec<HostSkillRoot> {if input.bundled_skills_enabled {self.ensure_system_skills_installed();}@@ -247,7 +246,7 @@ impl HostSkillsService {async fn snapshot_for_skill_roots(&self,input: &HostSkillsLoadInput,- roots: Vec<SkillRoot>,+ roots: Vec<HostSkillRoot>,skill_config_rules: &SkillConfigRules,cache_key: ConfigSkillsCacheKey,force_reload: bool,@@ -285,33 +284,9 @@ impl HostSkillsService {async fn build_skill_outcome(&self,input: &HostSkillsLoadInput,- roots: Vec<SkillRoot>,+ roots: Vec<HostSkillRoot>,skill_config_rules: &SkillConfigRules,) -> SkillLoadOutcome {- let roots = roots- .into_iter()- .map(|root| {- match (- root.plugin_identity,- root.plugin_namespace,- root.plugin_root,- ) {- (Some(plugin_identity), Some(plugin_namespace), Some(plugin_root)) => {- HostSkillRoot::plugin(- PluginSkillRoot {- path: root.path,- plugin_identity,- plugin_namespace,- plugin_root,- discovery_mode: root.discovery_mode,- },- root.file_system,- )- }- _ => HostSkillRoot::host(root.path, root.scope, root.file_system),- }- })- .collect();let outcome = load_and_merge_host_skill_roots(roots,&self.root_scan_slots,@@ -466,7 +441,7 @@ pub fn bundled_skills_enabled_from_stack(}fn config_skills_cache_key(- roots: &[SkillRoot],+ roots: &[HostSkillRoot],skill_config_rules: &SkillConfigRules,plugin_skill_snapshots: Option<&SkillRootSnapshots<PluginSkillRoot>>,) -> ConfigSkillsCacheKey {@@ -483,15 +458,15 @@ fn config_skills_cache_key(ConfigSkillRootCacheKey {path: root.path.clone(),scope_rank,- plugin_identity: root.plugin_identity.clone(),- plugin_namespace: root.plugin_namespace.clone(),+ plugin_identity: root.plugin_identity().cloned(),+ plugin_namespace: root.plugin_namespace().map(str::to_string),file_system: FileSystemIdentity(Arc::downgrade(&root.file_system)),}}).collect(),skill_config_rules: skill_config_rules.clone(),plugin_skill_snapshots: plugin_skill_snapshots- .filter(|_| roots.iter().any(|root| root.plugin_identity.is_some()))+ .filter(|_| roots.iter().any(|root| root.plugin_identity().is_some())).cloned(),}}diff --git a/codex-rs/ext/skills/src/lib.rs b/codex-rs/ext/skills/src/lib.rsindex 5416e30d02..eba9e6e8c2 100644--- a/codex-rs/ext/skills/src/lib.rs+++ b/codex-rs/ext/skills/src/lib.rs@@ -28,6 +28,7 @@ pub use host_service::HostSkillsLoadInput;pub use host_service::HostSkillsService;pub use host_service::bundled_skills_enabled_from_stack;pub use host_snapshot::HostSkillsSnapshot;+pub use loader::HostSkillRoot;pub use provider::ExecutorSkillProvider;pub use provider::HostSkillProvider;pub use provider::OrchestratorSkillProvider;diff --git a/codex-rs/ext/skills/src/loader/discovery.rs b/codex-rs/ext/skills/src/loader/discovery.rsindex 50e06533a6..8d55776444 100644--- a/codex-rs/ext/skills/src/loader/discovery.rs+++ b/codex-rs/ext/skills/src/loader/discovery.rs@@ -218,3 +218,7 @@ fn discover_skill_metadata(SkillMetadataDiscovery::Probe(metadata_path)}}++#[cfg(test)]+#[path = "discovery_tests.rs"]+mod tests;diff --git a/codex-rs/ext/skills/src/loader/discovery_tests.rs b/codex-rs/ext/skills/src/loader/discovery_tests.rsnew file mode 100644index 0000000000..294636e0d2--- /dev/null+++ b/codex-rs/ext/skills/src/loader/discovery_tests.rs@@ -0,0 +1,125 @@+use std::fs;+use std::path::Path;++use codex_exec_server::LOCAL_FS;+use codex_utils_path_uri::PathUri;+use codex_utils_plugins::SkillDiscoveryMode;+use pretty_assertions::assert_eq;+use tempfile::TempDir;++use super::DirectorySymlinkPolicy;+use super::HiddenDirectoryPolicy;+use super::SkillDiscovery;+use super::SkillDiscoveryOptions;+use super::discover_skills;++fn write_skill(root: &Path, directory: &str) {+ let path = root.join(directory).join("SKILL.md");+ fs::create_dir_all(path.parent().expect("skill parent")).expect("create skill directory");+ fs::write(path, "---\nname: demo\ndescription: Demo skill\n---\n")+ .expect("write skill frontmatter");+}++fn canonical_uri(path: &Path) -> PathUri {+ PathUri::from_host_native_path(fs::canonicalize(path).expect("canonical path"))+ .expect("absolute path URI")+}++async fn discover(root: &Path) -> SkillDiscovery {+ discover_skills(+ LOCAL_FS.as_ref(),+ &canonical_uri(root),+ SkillDiscoveryOptions {+ directory_symlinks: DirectorySymlinkPolicy::Follow,+ hidden_directories: HiddenDirectoryPolicy::Skip,+ mode: SkillDiscoveryMode::Recursive,+ },+ )+ .await+}++#[cfg(unix)]+#[tokio::test]+async fn discovers_hidden_directory_through_visible_symlink() {+ let root = TempDir::new().expect("root temp dir");+ write_skill(root.path(), ".hidden/search");+ std::os::unix::fs::symlink(root.path().join(".hidden"), root.path().join("visible"))+ .expect("create visible skill directory symlink");++ let discovery = discover(root.path()).await;++ assert_eq!(discovery.warnings, Vec::<String>::new());+ assert_eq!(+ discovery+ .skills+ .into_iter()+ .map(|skill| skill.path)+ .collect::<Vec<_>>(),+ vec![+ canonical_uri(root.path())+ .join("visible/search/SKILL.md")+ .expect("visible skill URI"),+ ]+ );+}++#[cfg(unix)]+#[tokio::test]+async fn ignores_symlinked_skill_files_and_directory_cycles() {+ let root = TempDir::new().expect("root temp dir");+ let external = TempDir::new().expect("external temp dir");+ write_skill(external.path(), "external");+ write_skill(root.path(), "cycle/demo");+ fs::create_dir_all(root.path().join("linked-file")).expect("create linked skill directory");+ std::os::unix::fs::symlink(+ external.path().join("external/SKILL.md"),+ root.path().join("linked-file/SKILL.md"),+ )+ .expect("create skill file symlink");+ std::os::unix::fs::symlink(root.path().join("cycle"), root.path().join("cycle/loop"))+ .expect("create directory symlink cycle");++ let discovery = tokio::time::timeout(+ std::time::Duration::from_secs(/*secs*/ 5),+ discover(root.path()),+ )+ .await+ .expect("directory symlink cycles must not prevent discovery from completing");++ assert_eq!(+ discovery+ .skills+ .into_iter()+ .map(|skill| skill.path)+ .collect::<Vec<_>>(),+ vec![+ canonical_uri(root.path())+ .join("cycle/demo/SKILL.md")+ .expect("valid skill URI"),+ ]+ );+}++#[tokio::test]+async fn respects_maximum_skill_scan_depth() {+ let root = TempDir::new().expect("root temp dir");+ let within_depth = "d0/d1/d2/d3/d4/d5";+ let beyond_depth = "d0/d1/d2/d3/d4/d5/d6";+ write_skill(root.path(), within_depth);+ write_skill(root.path(), beyond_depth);++ let discovery = discover(root.path()).await;++ assert_eq!(+ discovery+ .skills+ .into_iter()+ .map(|skill| skill.path)+ .collect::<Vec<_>>(),+ vec![+ canonical_uri(root.path())+ .join(&format!("{within_depth}/SKILL.md"))+ .expect("reachable skill URI"),+ ]+ );+}diff --git a/codex-rs/ext/skills/src/loader/environment_io_tests.rs b/codex-rs/ext/skills/src/loader/environment_io_tests.rsindex 0a02413dc0..fc95ec6093 100644--- a/codex-rs/ext/skills/src/loader/environment_io_tests.rs+++ b/codex-rs/ext/skills/src/loader/environment_io_tests.rs@@ -1,207 +1,17 @@use std::fs;-use std::sync::Mutex;-use std::sync::atomic::AtomicBool;-use std::sync::atomic::AtomicUsize;-use std::sync::atomic::Ordering;use std::time::Duration;-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_skills::EnvironmentSkillMetadata;use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;use tempfile::tempdir;-use tokio::sync::Notify;-use super::load_environment_skills_from_root;--#[derive(Clone, Copy)]-enum ManifestMetadataBehavior {- Immediate,- WaitForSkillRead,-}--struct RecordingFileSystem<'a> {- inner: &'a dyn ExecutorFileSystem,- read_files: Mutex<Vec<PathUri>>,- metadata_files: Mutex<Vec<PathUri>>,- walks: AtomicUsize,- manifest_metadata_behavior: ManifestMetadataBehavior,- skill_read_started: AtomicBool,- skill_read_started_notify: Notify,-}--#[derive(Debug, PartialEq, Eq)]-struct FileSystemCalls {- walks: usize,- read_files: Vec<PathUri>,- metadata_files: Vec<PathUri>,-}--impl<'a> RecordingFileSystem<'a> {- fn new(- inner: &'a dyn ExecutorFileSystem,- manifest_metadata_behavior: ManifestMetadataBehavior,- ) -> Self {- Self {- inner,- read_files: Mutex::new(Vec::new()),- metadata_files: Mutex::new(Vec::new()),- walks: AtomicUsize::new(0),- manifest_metadata_behavior,- skill_read_started: AtomicBool::new(false),- skill_read_started_notify: Notify::new(),- }- }-- fn calls(&self) -> FileSystemCalls {- let mut read_files = self- .read_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .clone();- read_files.sort_by_key(ToString::to_string);- let mut metadata_files = self- .metadata_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .clone();- metadata_files.sort_by_key(ToString::to_string);- FileSystemCalls {- walks: self.walks.load(Ordering::Relaxed),- read_files,- metadata_files,- }- }-}--impl ExecutorFileSystem for RecordingFileSystem<'_> {- 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.read_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .push(path.clone());- if path.basename().as_deref() == Some("SKILL.md") {- self.skill_read_started.store(true, Ordering::Release);- self.skill_read_started_notify.notify_waiters();- }- 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> {- self.metadata_files- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .push(path.clone());- if matches!(- self.manifest_metadata_behavior,- ManifestMetadataBehavior::WaitForSkillRead- ) && path.basename().as_deref() == Some("plugin.json")- {- return Box::pin(async move {- loop {- let notified = self.skill_read_started_notify.notified();- if self.skill_read_started.load(Ordering::Acquire) {- break;- }- notified.await;- }- self.inner.get_metadata(path, sandbox).await- });- }- self.inner.get_metadata(path, sandbox)- }+use crate::loader::io_test_support::FileSystemCalls;+use crate::loader::io_test_support::ManifestMetadataBehavior;+use crate::loader::io_test_support::RecordingFileSystem;- 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.walks.fetch_add(1, Ordering::Relaxed);- 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)- }-}+use super::load_environment_skills_from_root;#[tokio::test]async fn loads_nearest_plugin_namespaces_without_reading_unused_sibling_manifests() {diff --git a/codex-rs/ext/skills/src/loader/environment_tests.rs b/codex-rs/ext/skills/src/loader/environment_tests.rsindex 884b53aee5..59305a3e93 100644--- a/codex-rs/ext/skills/src/loader/environment_tests.rs+++ b/codex-rs/ext/skills/src/loader/environment_tests.rs@@ -1,18 +1,92 @@use std::fs;-use codex_core_skills::loader::load_environment_skills_from_root;use codex_exec_server::CapabilityRootDiscoverRequest;use codex_exec_server::CapabilityRootsDiscoverParams;use codex_exec_server::LOCAL_FS;use codex_exec_server::discover_capability_roots;+use codex_protocol::protocol::Product;+use codex_skills::EnvironmentSkillMetadata;+use codex_skills::SkillDependencies;+use codex_skills::SkillPolicy;+use codex_skills::SkillToolDependency;use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;use tempfile::tempdir;use super::load_environment_skills_from_discovery;+use super::load_environment_skills_from_root;#[tokio::test]-async fn executor_bundle_parser_matches_the_existing_environment_loader() {+async fn direct_environment_loader_preserves_plugin_dependencies_and_product_policy() {+ let root = tempdir().expect("tempdir");+ let skill_dir = root.path().join("skills/deploy");+ fs::create_dir_all(root.path().join(".codex-plugin")).expect("manifest dir");+ fs::create_dir_all(skill_dir.join("agents")).expect("metadata dir");+ fs::write(+ root.path().join(".codex-plugin/plugin.json"),+ r#"{"name":"demo-plugin"}"#,+ )+ .expect("manifest");+ fs::write(+ skill_dir.join("SKILL.md"),+ "---\nname: deploy\ndescription: Deploy the service.\n---\n",+ )+ .expect("skill");+ fs::write(+ skill_dir.join("agents/openai.yaml"),+ r#"+dependencies:+ tools:+ - type: mcp+ value: deploy-server+ description: Deploy MCP+ transport: stdio+ command: deploy-mcp+policy:+ allow_implicit_invocation: false+ products: [codex, atlas]+"#,+ )+ .expect("metadata");++ let root_uri = PathUri::from_host_native_path(root.path()).expect("root URI");+ let outcome =+ load_environment_skills_from_root(LOCAL_FS.as_ref(), &root_uri, Some(Product::Codex)).await;++ assert_eq!(+ outcome.skills,+ vec![EnvironmentSkillMetadata {+ path_to_skills_md: PathUri::from_host_native_path(skill_dir.join("SKILL.md")).unwrap(),+ name: "demo-plugin:deploy".to_string(),+ description: "Deploy the service.".to_string(),+ short_description: None,+ dependencies: Some(SkillDependencies {+ tools: vec![SkillToolDependency {+ r#type: "mcp".to_string(),+ value: "deploy-server".to_string(),+ description: Some("Deploy MCP".to_string()),+ transport: Some("stdio".to_string()),+ command: Some("deploy-mcp".to_string()),+ url: None,+ }],+ }),+ policy: Some(SkillPolicy {+ allow_implicit_invocation: Some(false),+ products: vec![Product::Codex, Product::Atlas],+ }),+ }]+ );+ let atlas =+ load_environment_skills_from_root(LOCAL_FS.as_ref(), &root_uri, Some(Product::Atlas)).await;+ assert_eq!(atlas.skills, outcome.skills);+ let filtered =+ load_environment_skills_from_root(LOCAL_FS.as_ref(), &root_uri, Some(Product::Chatgpt))+ .await;+ assert!(filtered.skills.is_empty());+}++#[tokio::test]+async fn executor_bundle_parser_matches_direct_environment_loader() {let root = tempdir().expect("tempdir");let plugin_manifest = root.path().join(".codex-plugin/plugin.json");let nested_manifest = root.path().join("nested/.claude-plugin/plugin.json");diff --git a/codex-rs/ext/skills/src/loader/host.rs b/codex-rs/ext/skills/src/loader/host.rsindex f0029638a5..4c654f1645 100644--- a/codex-rs/ext/skills/src/loader/host.rs+++ b/codex-rs/ext/skills/src/loader/host.rs@@ -75,7 +75,8 @@ impl HostSkillRoot {}}- pub(crate) fn plugin_identity(&self) -> Option<&PluginIdentity> {+ /// Returns the owning plugin identity when this root belongs to a plugin.+ pub fn plugin_identity(&self) -> Option<&PluginIdentity> {self.plugin.as_ref().map(|plugin| &plugin.identity)}@@ -404,3 +405,7 @@ async fn canonicalize_for_skill_identity(#[cfg(test)]#[path = "host_tests.rs"]mod tests;++#[cfg(all(test, unix))]+#[path = "host_io_tests.rs"]+mod io_tests;diff --git a/codex-rs/ext/skills/src/loader/host_io_tests.rs b/codex-rs/ext/skills/src/loader/host_io_tests.rsnew file mode 100644index 0000000000..a3b8f92a60--- /dev/null+++ b/codex-rs/ext/skills/src/loader/host_io_tests.rs@@ -0,0 +1,138 @@+use std::fs;+use std::os::unix::fs::symlink;+use std::sync::Arc;++use codex_exec_server::ExecutorFileSystem;+use codex_exec_server::LOCAL_FS;+use codex_protocol::protocol::SkillScope;+use codex_skills::SkillMetadata;+use codex_skills::SkillPolicy;+use codex_utils_absolute_path::test_support::PathBufExt;+use codex_utils_path_uri::PathUri;+use pretty_assertions::assert_eq;+use tempfile::tempdir;+use tokio::sync::Semaphore;++use crate::loader::HostSkillRoot;+use crate::loader::MAX_CONCURRENT_ROOT_SCANS;+use crate::loader::io_test_support::ManifestMetadataBehavior;+use crate::loader::io_test_support::RecordingFileSystem;+use crate::loader::load_and_merge_host_skill_roots;++#[tokio::test]+async fn host_loading_reuses_walk_inventory_for_symlinked_skill_pack() {+ let root = tempdir().expect("tempdir");+ let shared_plugin_root = tempdir().expect("tempdir");+ let manifest_path = shared_plugin_root.path().join(".codex-plugin/plugin.json");+ fs::create_dir_all(manifest_path.parent().expect("manifest parent")).expect("manifest dir");+ fs::write(&manifest_path, r#"{"name":"linked"}"#).expect("manifest");++ let skills_root = shared_plugin_root.path().join("skills");+ for name in ["first", "second"] {+ let skill_path = skills_root.join(name).join("SKILL.md");+ fs::create_dir_all(skill_path.parent().expect("skill parent")).expect("skill dir");+ fs::write(+ &skill_path,+ format!("---\nname: {name}\ndescription: {name} skill.\n---\n"),+ )+ .expect("skill");+ }+ let metadata_path = skills_root.join("first/agents/openai.yaml");+ fs::create_dir_all(metadata_path.parent().expect("metadata parent")).expect("metadata dir");+ fs::write(+ &metadata_path,+ "policy:\n allow_implicit_invocation: false\n",+ )+ .expect("metadata");++ let host_root = root.path().join("skills");+ fs::create_dir_all(&host_root).expect("host skills dir");+ let linked_root = host_root.join("linked-plugin");+ symlink(&skills_root, &linked_root).expect("skill pack symlink");++ let recording = Arc::new(RecordingFileSystem::new(+ LOCAL_FS.as_ref(),+ ManifestMetadataBehavior::Immediate,+ ));+ let file_system: Arc<dyn ExecutorFileSystem> = recording.clone();+ let root_scan_slots = Semaphore::new(MAX_CONCURRENT_ROOT_SCANS);+ let future = load_and_merge_host_skill_roots(+ vec![HostSkillRoot::host(+ host_root.abs(),+ SkillScope::User,+ file_system,+ )],+ &root_scan_slots,+ /*restriction_product*/ None,+ /*plugin_skill_snapshots*/ None,+ );+ fn assert_send<T: Send>(_: &T) {}+ assert_send(&future);+ let outcome = future.await;++ assert_eq!(outcome.errors, Vec::new());+ let first_skill_path = dunce::canonicalize(skills_root.join("first/SKILL.md"))+ .unwrap()+ .abs();+ let second_skill_path = dunce::canonicalize(skills_root.join("second/SKILL.md"))+ .unwrap()+ .abs();+ assert_eq!(+ outcome.skills,+ vec![+ SkillMetadata {+ name: "linked:first".to_string(),+ description: "first skill.".to_string(),+ short_description: None,+ interface: None,+ dependencies: None,+ policy: Some(SkillPolicy {+ allow_implicit_invocation: Some(false),+ products: Vec::new(),+ }),+ path_to_skills_md: first_skill_path,+ scope: SkillScope::User,+ plugin_id: None,+ remote_plugin_id: None,+ },+ SkillMetadata {+ name: "linked:second".to_string(),+ description: "second skill.".to_string(),+ short_description: None,+ interface: None,+ dependencies: None,+ policy: None,+ path_to_skills_md: second_skill_path,+ scope: SkillScope::User,+ plugin_id: None,+ remote_plugin_id: None,+ },+ ]+ );++ let calls = recording.calls();+ assert_eq!(calls.walks, 1);+ let linked_root = PathUri::from_host_native_path(linked_root).unwrap();+ assert!(+ calls+ .read_files+ .iter()+ .all(|path| !path.starts_with(&linked_root))+ );+ assert!(+ calls+ .metadata_files+ .iter()+ .all(|path| path.basename().as_deref() != Some("openai.yaml"))+ );+ let manifest_uri =+ PathUri::from_host_native_path(dunce::canonicalize(manifest_path).unwrap()).unwrap();+ assert_eq!(+ calls+ .metadata_files+ .iter()+ .filter(|path| **path == manifest_uri)+ .count(),+ 1+ );+}diff --git a/codex-rs/ext/skills/src/loader/host_merge.rs b/codex-rs/ext/skills/src/loader/host_merge.rsindex 3bbfafcf9a..6fcb5a4b03 100644--- a/codex-rs/ext/skills/src/loader/host_merge.rs+++ b/codex-rs/ext/skills/src/loader/host_merge.rs@@ -3,7 +3,6 @@ use std::collections::HashSet;use std::sync::Arc;use codex_core_skills::SkillLoadOutcome;-use codex_core_skills::loader::MAX_CONCURRENT_ROOT_SCANS;use codex_exec_server::ExecutorFileSystem;use codex_protocol::protocol::Product;use codex_protocol::protocol::SkillScope;@@ -18,6 +17,7 @@ use tokio::sync::OnceCell;use tokio::sync::Semaphore;use super::HostSkillRoot;+use super::MAX_CONCURRENT_ROOT_SCANS;use super::host::HostSkillRootSnapshot;use super::load_host_skill_root;diff --git a/codex-rs/ext/skills/src/loader/host_merge_tests.rs b/codex-rs/ext/skills/src/loader/host_merge_tests.rsindex ccd593d93c..0444278b41 100644--- a/codex-rs/ext/skills/src/loader/host_merge_tests.rs+++ b/codex-rs/ext/skills/src/loader/host_merge_tests.rs@@ -2,13 +2,19 @@ use std::collections::HashMap;use std::fs;use std::sync::Arc;use std::sync::Mutex;+use std::sync::atomic::Ordering;+use codex_exec_server::ExecutorFileSystem;use codex_exec_server::LOCAL_FS;use codex_protocol::protocol::Product;+use codex_protocol::protocol::SkillScope;use codex_skills::LoadedSkillRoot;+use codex_skills::SkillError;use codex_skills::SkillRootSnapshotCache;use codex_skills::SkillRootSnapshots;use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_absolute_path::test_support::PathBufExt;+use codex_utils_path_uri::PathUri;use codex_utils_plugins::PluginIdentity;use codex_utils_plugins::PluginSkillRoot;use codex_utils_plugins::SkillDiscoveryMode;@@ -17,6 +23,10 @@ use pretty_assertions::assert_eq;use tempfile::TempDir;use tokio::sync::Semaphore;+use crate::loader::MAX_CONCURRENT_ROOT_SCANS;+use crate::loader::io_test_support::ManifestMetadataBehavior;+use crate::loader::io_test_support::RecordingFileSystem;+use super::HostSkillRoot;use super::load_and_merge_host_skill_roots;@@ -311,3 +321,188 @@ async fn recognizes_symlinked_migrated_command_roots() {]);}++#[tokio::test]+async fn host_root_scans_wait_for_shared_capacity() {+ let temp = TempDir::new().expect("temp dir");+ let root = AbsolutePathBuf::from_absolute_path(temp.path()).expect("absolute skill root");+ let root_scan_slots = Semaphore::new(/*permits*/ 1);+ let held_slot = root_scan_slots+ .try_acquire()+ .expect("root scan slot should be available");+ let load = load_and_merge_host_skill_roots(+ vec![HostSkillRoot::host(+ root,+ SkillScope::Repo,+ Arc::clone(&LOCAL_FS),+ )],+ &root_scan_slots,+ /*restriction_product*/ None,+ /*plugin_skill_snapshots*/ None,+ );+ tokio::pin!(load);++ assert!(futures::poll!(load.as_mut()).is_pending());+ drop(held_slot);+ let outcome = load.await;++ assert_eq!(outcome.skills, Vec::new());+ assert_eq!(outcome.errors, Vec::new());+}++#[tokio::test]+async fn duplicate_host_root_paths_preserve_first_root_scope() {+ let temp = TempDir::new().expect("temp dir");+ let root = AbsolutePathBuf::from_absolute_path(temp.path()).expect("absolute skill root");+ write_skill(&root, "demo", "demo", "Shared skill");++ let outcome = load_and_merge_host_skill_roots(+ vec![+ HostSkillRoot::host(root.clone(), SkillScope::Repo, Arc::clone(&LOCAL_FS)),+ HostSkillRoot::host(root.clone(), SkillScope::User, Arc::clone(&LOCAL_FS)),+ ],+ &Semaphore::new(/*permits*/ 2),+ /*restriction_product*/ None,+ /*plugin_skill_snapshots*/ None,+ )+ .await;++ assert_eq!(outcome.errors, Vec::new());+ assert_eq!(outcome.skills.len(), 1);+ assert_eq!(outcome.skills[0].scope, SkillScope::Repo);+ let canonical_root = AbsolutePathBuf::from_absolute_path(+ fs::canonicalize(root.as_path()).expect("canonicalize skill root"),+ )+ .expect("absolute canonical skill root");+ assert_eq!(+ outcome.skill_root_for_path(&outcome.skills[0].path_to_skills_md),+ Some(&canonical_root)+ );+}++#[cfg(unix)]+#[tokio::test]+async fn deduplicated_symlinked_skill_preserves_first_discovery_path() {+ let source = TempDir::new().expect("source temp dir");+ let first = TempDir::new().expect("first root temp dir");+ let second = TempDir::new().expect("second root temp dir");+ let source_root =+ AbsolutePathBuf::from_absolute_path(source.path()).expect("absolute source root");+ let first_root =+ AbsolutePathBuf::from_absolute_path(first.path()).expect("absolute first root");+ let second_root =+ AbsolutePathBuf::from_absolute_path(second.path()).expect("absolute second root");+ write_skill(&source_root, "demo", "demo", "Shared skill");+ std::os::unix::fs::symlink(source.path().join("demo"), first.path().join("first-link"))+ .expect("create first skill directory symlink");+ std::os::unix::fs::symlink(+ source.path().join("demo"),+ second.path().join("second-link"),+ )+ .expect("create second skill directory symlink");++ let outcome = load_and_merge_host_skill_roots(+ vec![+ HostSkillRoot::host(first_root.clone(), SkillScope::Repo, Arc::clone(&LOCAL_FS)),+ HostSkillRoot::host(second_root, SkillScope::User, Arc::clone(&LOCAL_FS)),+ ],+ &Semaphore::new(/*permits*/ 2),+ /*restriction_product*/ None,+ /*plugin_skill_snapshots*/ None,+ )+ .await;++ assert_eq!(outcome.errors, Vec::new());+ assert_eq!(outcome.skills.len(), 1);+ let skill_path = &outcome.skills[0].path_to_skills_md;+ let canonical_first_root = AbsolutePathBuf::from_absolute_path(+ fs::canonicalize(first_root.as_path()).expect("canonicalize first skill root"),+ )+ .expect("absolute first skill root");+ assert_eq!(+ (+ outcome.skill_root_for_path(skill_path),+ outcome.skill_discovery_path_for_path(skill_path),+ ),+ (+ Some(&canonical_first_root),+ Some(&canonical_first_root.join("first-link/SKILL.md")),+ )+ );+}++#[tokio::test]+async fn merges_host_root_results_in_input_order_when_scans_finish_out_of_order() {+ const ROOT_COUNT: usize = MAX_CONCURRENT_ROOT_SCANS + 1;++ let temp = TempDir::new().expect("temp dir");+ let roots = (0..ROOT_COUNT)+ .map(|index| temp.path().join(format!("root-{index}")))+ .collect::<Vec<_>>();+ for root in &roots {+ fs::create_dir_all(root).expect("create skill root");+ }+ let first_skill = roots[0].join("broken/SKILL.md");+ let second_skill = roots[1].join("broken/SKILL.md");+ for path in [&first_skill, &second_skill] {+ fs::create_dir_all(path.parent().expect("skill parent"))+ .expect("create invalid skill directory");+ fs::write(path, "missing frontmatter").expect("write invalid skill");+ }++ let mut recording =+ RecordingFileSystem::new(LOCAL_FS.as_ref(), ManifestMetadataBehavior::Immediate);+ recording.blocked_walk_root = Some(PathUri::from_abs_path(+ &dunce::canonicalize(&roots[0])+ .expect("canonical blocked skill root")+ .abs(),+ ));+ let recording = Arc::new(recording);+ let file_system: Arc<dyn ExecutorFileSystem> = recording.clone();+ let host_roots = roots+ .iter()+ .map(|root| HostSkillRoot::host(root.clone().abs(), SkillScope::User, file_system.clone()))+ .collect::<Vec<_>>();+ let load = tokio::spawn(async move {+ load_and_merge_host_skill_roots(+ host_roots,+ &Semaphore::new(MAX_CONCURRENT_ROOT_SCANS),+ /*restriction_product*/ None,+ /*plugin_skill_snapshots*/ None,+ )+ .await+ });++ tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), async {+ loop {+ let walk_started = recording.walk_started.notified();+ if recording.walks.load(Ordering::Acquire) == ROOT_COUNT {+ break;+ }+ walk_started.await;+ }+ })+ .await+ .expect("all host root scans should start despite the blocked first root");+ recording.blocked_walk_gate.add_permits(/*n*/ 1);+ let outcome = load.await.expect("host skill root loading should complete");++ assert_eq!(outcome.skills, Vec::new());+ assert_eq!(+ outcome.errors,+ vec![+ SkillError {+ path: dunce::canonicalize(first_skill)+ .expect("canonical first invalid skill path")+ .abs(),+ message: "missing YAML frontmatter delimited by ---".to_string(),+ },+ SkillError {+ path: dunce::canonicalize(second_skill)+ .expect("canonical second invalid skill path")+ .abs(),+ message: "missing YAML frontmatter delimited by ---".to_string(),+ },+ ]+ );+}diff --git a/codex-rs/ext/skills/src/loader/host_tests.rs b/codex-rs/ext/skills/src/loader/host_tests.rsindex c5d85750e4..ddaa00442e 100644--- a/codex-rs/ext/skills/src/loader/host_tests.rs+++ b/codex-rs/ext/skills/src/loader/host_tests.rs@@ -119,7 +119,7 @@ async fn loads_host_frontmatter_dependencies_and_policy() {description: Demo toolpolicy:allow_implicit_invocation: false- products: [codex]+ products: [codex, CHATGPT, atlas]"##,);@@ -145,7 +145,7 @@ policy:}),policy: Some(SkillPolicy {allow_implicit_invocation: Some(false),- products: vec![Product::Codex],+ products: vec![Product::Codex, Product::Chatgpt, Product::Atlas],}),path_to_skills_md: skill_path,scope: SkillScope::User,@@ -433,6 +433,41 @@ async fn plugin_root_accepts_maximum_length_qualified_skill_name() {);}+#[tokio::test]+async fn plugin_root_rejects_overlong_qualified_skill_name() {+ let root = TempDir::new().expect("temp dir");+ let skill_name = "s".repeat(MAX_NAME_LEN);+ write_skill(+ &root,+ "skills/search",+ &format!("name: {skill_name}\ndescription: Search skill"),+ );+ let plugin_root = AbsolutePathBuf::from_absolute_path(root.path()).expect("plugin root");++ let snapshot = load_host_skill_root(HostSkillRoot::plugin(+ PluginSkillRoot {+ path: plugin_root.join("skills"),+ plugin_identity: PluginIdentity {+ plugin_id: "demo@test".to_string(),+ remote_plugin_id: None,+ },+ plugin_namespace: "p".repeat(MAX_NAME_LEN + 1),+ plugin_root,+ discovery_mode: SkillDiscoveryMode::Recursive,+ },+ Arc::clone(&LOCAL_FS),+ ))+ .await;++ assert_eq!(snapshot.skills, Vec::new());+ assert_eq!(snapshot.errors.len(), 1);+ assert!(+ snapshot.errors[0]+ .message+ .contains("invalid qualified name")+ );+}+#[tokio::test]async fn recursive_plugin_root_preserves_owner_namespace_and_shared_asset_policy() {let root = TempDir::new().expect("temp dir");@@ -638,7 +673,7 @@ async fn recursive_plugin_root_preserves_symlinked_skill_discovery_path() {#[cfg(unix)]#[tokio::test]-async fn follows_directory_symlinks_for_user_but_not_system_scope() {+async fn follows_directory_symlinks_except_for_system_scope() {use std::os::unix::fs::symlink;let root = TempDir::new().expect("temp dir");@@ -646,18 +681,25 @@ async fn follows_directory_symlinks_for_user_but_not_system_scope() {let target_skill = write_skill(&target, "demo", "name: demo\ndescription: Symlinked skill");symlink(target.path().join("demo"), root.path().join("alias")).expect("create symlink");- let user_snapshot = load_host_skill_root(root_for(&root, SkillScope::User)).await;- let system_snapshot = load_host_skill_root(root_for(&root, SkillScope::System)).await;+ for scope in [SkillScope::User, SkillScope::Repo, SkillScope::Admin] {+ let snapshot = load_host_skill_root(root_for(&root, scope)).await;++ assert_eq!(snapshot.errors, Vec::new());+ assert_eq!(snapshot.skills.len(), 1);+ assert_eq!(+ (+ &snapshot.skills[0].path_to_skills_md,+ snapshot.skills[0].scope+ ),+ (&target_skill, scope)+ );+ assert_eq!(+ snapshot.skill_discovery_path_by_path.get(&target_skill),+ Some(&snapshot.root.join("alias/SKILL.md"))+ );+ }- assert_eq!(user_snapshot.errors, Vec::new());- assert_eq!(user_snapshot.skills.len(), 1);- assert_eq!(user_snapshot.skills[0].path_to_skills_md, target_skill);- assert_eq!(- user_snapshot- .skill_discovery_path_by_path- .get(&target_skill),- Some(&user_snapshot.root.join("alias/SKILL.md"))- );+ let system_snapshot = load_host_skill_root(root_for(&root, SkillScope::System)).await;assert_eq!(system_snapshot.errors, Vec::new());assert_eq!(system_snapshot.skills, Vec::new());}diff --git a/codex-rs/ext/skills/src/loader/io_test_support.rs b/codex-rs/ext/skills/src/loader/io_test_support.rsnew file mode 100644index 0000000000..4972cffdcf--- /dev/null+++ b/codex-rs/ext/skills/src/loader/io_test_support.rs@@ -0,0 +1,214 @@+use std::sync::Mutex;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::AtomicUsize;+use std::sync::atomic::Ordering;++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::ReadDirectoryEntry;+use codex_exec_server::RemoveOptions;+use codex_exec_server::WalkOptions;+use codex_exec_server::WalkOutcome;+use codex_utils_path_uri::PathUri;+use tokio::sync::Notify;+use tokio::sync::Semaphore;++#[derive(Clone, Copy)]+pub(super) enum ManifestMetadataBehavior {+ Immediate,+ WaitForSkillRead,+}++pub(super) struct RecordingFileSystem<'a> {+ inner: &'a dyn ExecutorFileSystem,+ read_files: Mutex<Vec<PathUri>>,+ metadata_files: Mutex<Vec<PathUri>>,+ pub(super) walks: AtomicUsize,+ manifest_metadata_behavior: ManifestMetadataBehavior,+ skill_read_started: AtomicBool,+ skill_read_started_notify: Notify,+ pub(super) blocked_walk_root: Option<PathUri>,+ pub(super) blocked_walk_gate: Semaphore,+ pub(super) walk_started: Notify,+}++#[derive(Debug, PartialEq, Eq)]+pub(super) struct FileSystemCalls {+ pub(super) walks: usize,+ pub(super) read_files: Vec<PathUri>,+ pub(super) metadata_files: Vec<PathUri>,+}++impl<'a> RecordingFileSystem<'a> {+ pub(super) fn new(+ inner: &'a dyn ExecutorFileSystem,+ manifest_metadata_behavior: ManifestMetadataBehavior,+ ) -> Self {+ Self {+ inner,+ read_files: Mutex::new(Vec::new()),+ metadata_files: Mutex::new(Vec::new()),+ walks: AtomicUsize::new(/*v*/ 0),+ manifest_metadata_behavior,+ skill_read_started: AtomicBool::new(/*v*/ false),+ skill_read_started_notify: Notify::new(),+ blocked_walk_root: None,+ blocked_walk_gate: Semaphore::new(/*permits*/ 0),+ walk_started: Notify::new(),+ }+ }++ pub(super) fn calls(&self) -> FileSystemCalls {+ let mut read_files = self+ .read_files+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .clone();+ read_files.sort_by_key(ToString::to_string);+ let mut metadata_files = self+ .metadata_files+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .clone();+ metadata_files.sort_by_key(ToString::to_string);+ FileSystemCalls {+ walks: self.walks.load(Ordering::Relaxed),+ read_files,+ metadata_files,+ }+ }+}++impl ExecutorFileSystem for RecordingFileSystem<'_> {+ 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.read_files+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .push(path.clone());+ if path.basename().as_deref() == Some("SKILL.md") {+ self.skill_read_started.store(true, Ordering::Release);+ self.skill_read_started_notify.notify_waiters();+ }+ 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> {+ self.metadata_files+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .push(path.clone());+ if matches!(+ self.manifest_metadata_behavior,+ ManifestMetadataBehavior::WaitForSkillRead+ ) && path.basename().as_deref() == Some("plugin.json")+ {+ return Box::pin(async move {+ loop {+ let notified = self.skill_read_started_notify.notified();+ if self.skill_read_started.load(Ordering::Acquire) {+ break;+ }+ notified.await;+ }+ self.inner.get_metadata(path, sandbox).await+ });+ }+ self.inner.get_metadata(path, sandbox)+ }++ 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.walks.fetch_add(/*val*/ 1, Ordering::AcqRel);+ self.walk_started.notify_waiters();+ if self.blocked_walk_root.as_ref() != Some(path) {+ return self.inner.walk(path, options, sandbox);+ }+ Box::pin(async move {+ self.blocked_walk_gate+ .acquire()+ .await+ .expect("blocked walk gate should remain open")+ .forget();+ self.inner.walk(path, options, sandbox).await+ })+ }++ 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)+ }+}diff --git a/codex-rs/ext/skills/src/loader/mod.rs b/codex-rs/ext/skills/src/loader/mod.rsindex eced4944bf..a94cc6a0c3 100644--- a/codex-rs/ext/skills/src/loader/mod.rs+++ b/codex-rs/ext/skills/src/loader/mod.rs@@ -2,15 +2,18 @@ mod discovery;mod environment;mod host;mod host_merge;+#[cfg(test)]+mod io_test_support;mod metadata;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 use host::HostSkillRoot;pub(crate) use host::load_host_skill_root;pub(crate) use host_merge::load_and_merge_host_skill_roots;+pub(crate) const MAX_CONCURRENT_ROOT_SCANS: usize = 8;pub(super) const SKILLS_FILENAME: &str = "SKILL.md";pub(super) const SKILLS_METADATA_DIR: &str = "agents";pub(super) const SKILLS_METADATA_FILENAME: &str = "openai.yaml";diff --git a/codex-rs/ext/skills/src/loader/namespace.rs b/codex-rs/ext/skills/src/loader/namespace.rsindex 687238138b..5dac7538ae 100644--- a/codex-rs/ext/skills/src/loader/namespace.rs+++ b/codex-rs/ext/skills/src/loader/namespace.rs@@ -180,3 +180,7 @@ impl ResolvedSkillNamespace {}}}++#[cfg(test)]+#[path = "namespace_tests.rs"]+mod tests;diff --git a/codex-rs/ext/skills/src/loader/namespace_tests.rs b/codex-rs/ext/skills/src/loader/namespace_tests.rsnew file mode 100644index 0000000000..a85a3afb8e--- /dev/null+++ b/codex-rs/ext/skills/src/loader/namespace_tests.rs@@ -0,0 +1,172 @@+use std::collections::HashSet;+use std::fs;+use std::path::Path;+#[cfg(unix)]+use std::sync::Arc;++use codex_exec_server::LOCAL_FS;+#[cfg(unix)]+use codex_protocol::protocol::SkillScope;+#[cfg(unix)]+use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_path_uri::PathUri;+use pretty_assertions::assert_eq;+use tempfile::TempDir;++#[cfg(unix)]+use crate::loader::HostSkillRoot;+#[cfg(unix)]+use crate::loader::load_host_skill_root;++use super::SkillNamespaceResolver;++fn canonical_uri(path: &Path) -> PathUri {+ PathUri::from_host_native_path(fs::canonicalize(path).expect("canonical path"))+ .expect("absolute path URI")+}++fn write_skill(root: &Path, directory: &str) -> PathUri {+ let path = root.join(directory).join("SKILL.md");+ fs::create_dir_all(path.parent().expect("skill parent")).expect("create skill directory");+ fs::write(&path, "---\nname: skill\ndescription: Demo skill\n---\n")+ .expect("write skill frontmatter");+ canonical_uri(&path)+}++fn write_manifest(root: &Path, contents: &str) -> PathUri {+ let path = root.join(".codex-plugin/plugin.json");+ fs::create_dir_all(path.parent().expect("manifest parent"))+ .expect("create plugin manifest directory");+ fs::write(path, contents).expect("write plugin manifest");+ canonical_uri(root)+}++async fn namespaces_for(+ root: &Path,+ skill_paths: &[PathUri],+ plugin_roots: HashSet<PathUri>,+ mut namespace_roots: HashSet<PathUri>,+) -> Vec<String> {+ let root = canonical_uri(root);+ namespace_roots.insert(root.clone());+ let resolver = SkillNamespaceResolver::discover(+ LOCAL_FS.as_ref(),+ &root,+ skill_paths,+ plugin_roots,+ namespace_roots,+ )+ .await;++ skill_paths+ .iter()+ .map(|path| resolver.for_skill(&root, path).qualify("skill"))+ .collect()+}++#[tokio::test]+async fn nested_plugin_namespaces_do_not_apply_to_plain_siblings() {+ let root = TempDir::new().expect("root temp dir");+ let nested_plugin = root.path().join("nested-plugin");+ let plugin_root = write_manifest(&nested_plugin, r#"{"name":"nested"}"#);+ let plain_skill = write_skill(root.path(), "plain");+ let nested_skill = write_skill(&nested_plugin, "skills/search");++ let namespaces = namespaces_for(+ root.path(),+ &[plain_skill, nested_skill],+ HashSet::from([plugin_root]),+ HashSet::new(),+ )+ .await;++ assert_eq!(namespaces, vec!["skill", "nested:skill"]);+}++#[tokio::test]+async fn nearest_valid_manifest_overrides_or_falls_back_to_outer_namespace() {+ let root = TempDir::new().expect("root temp dir");+ let plugin_root = root.path().join("outer");+ let skills_root = plugin_root.join("skills");+ let nested_plugin = skills_root.join("nested");+ let invalid_plugin = skills_root.join("invalid");+ write_manifest(&plugin_root, r#"{"name":"outer"}"#);+ let nested_root = write_manifest(&nested_plugin, r#"{"name":"nested"}"#);+ let invalid_root = write_manifest(&invalid_plugin, "not json");+ let direct_skill = write_skill(&skills_root, "direct");+ let nested_skill = write_skill(&nested_plugin, "skills/search");+ let fallback_skill = write_skill(&invalid_plugin, "skills/fallback");++ let namespaces = namespaces_for(+ &skills_root,+ &[direct_skill, nested_skill, fallback_skill],+ HashSet::from([nested_root, invalid_root]),+ HashSet::new(),+ )+ .await;++ assert_eq!(+ namespaces,+ vec!["outer:skill", "nested:skill", "outer:skill"]+ );+}++#[cfg(unix)]+#[tokio::test]+async fn symlinked_external_directories_do_not_inherit_plugin_namespace() {+ let root = TempDir::new().expect("root temp dir");+ let external = TempDir::new().expect("external temp dir");+ let plugin_root = root.path().join("outer");+ let skills_root = plugin_root.join("skills");+ write_manifest(&plugin_root, r#"{"name":"outer"}"#);+ write_skill(external.path(), "plain");+ fs::create_dir_all(&skills_root).expect("create skill root");+ std::os::unix::fs::symlink(external.path(), skills_root.join("linked"))+ .expect("create external directory symlink");++ let snapshot = load_host_skill_root(HostSkillRoot::host(+ AbsolutePathBuf::from_absolute_path(&skills_root).expect("absolute skills root"),+ SkillScope::User,+ Arc::clone(&LOCAL_FS),+ ))+ .await;++ assert_eq!(snapshot.errors, Vec::new());+ assert_eq!(+ snapshot+ .skills+ .into_iter()+ .map(|skill| skill.name)+ .collect::<Vec<_>>(),+ vec!["skill"]+ );+}++#[cfg(unix)]+#[tokio::test]+async fn ancestor_symlink_roots_preserve_inherited_plugin_namespace() {+ let root = TempDir::new().expect("root temp dir");+ let plugin_root = root.path().join("a/b/c/d/e/f/outer");+ let skills_root = plugin_root.join("skills");+ write_manifest(&plugin_root, r#"{"name":"outer"}"#);+ write_skill(&skills_root, "direct");+ std::os::unix::fs::symlink(root.path(), skills_root.join("ancestor"))+ .expect("create ancestor directory symlink");++ let snapshot = load_host_skill_root(HostSkillRoot::host(+ AbsolutePathBuf::from_absolute_path(&skills_root).expect("absolute skills root"),+ SkillScope::User,+ Arc::clone(&LOCAL_FS),+ ))+ .await;++ assert_eq!(snapshot.errors, Vec::new());+ assert_eq!(+ snapshot+ .skills+ .into_iter()+ .map(|skill| skill.name)+ .collect::<Vec<_>>(),+ vec!["outer:skill"]+ );+}diff --git a/codex-rs/ext/skills/src/provider/host_tests.rs b/codex-rs/ext/skills/src/provider/host_tests.rsindex 0d9b0b0cc2..6269585f60 100644--- a/codex-rs/ext/skills/src/provider/host_tests.rs+++ b/codex-rs/ext/skills/src/provider/host_tests.rs@@ -2,8 +2,6 @@ use std::sync::Arc;use std::time::SystemTime;use std::time::UNIX_EPOCH;-use codex_core_skills::loader::SkillRoot;-use codex_core_skills::loader::load_skills_from_roots;use codex_exec_server::LOCAL_FS;use codex_protocol::protocol::SkillScope;use codex_utils_absolute_path::AbsolutePathBuf;@@ -11,6 +9,8 @@ use pretty_assertions::assert_eq;use tokio::sync::Semaphore;use super::catalog_from_outcome;+use crate::loader::HostSkillRoot;+use crate::loader::load_and_merge_host_skill_roots;#[tokio::test]async fn host_catalog_entries_carry_their_render_metadata() -> Result<(), Box<dyn std::error::Error>>@@ -31,18 +31,15 @@ async fn host_catalog_entries_carry_their_render_metadata() -> Result<(), Box<dy"---\nname: demo\ndescription: Demo skill.\n---\n# Demo\n",)?;let root = AbsolutePathBuf::try_from(std::fs::canonicalize(root)?)?;- let outcome = load_skills_from_roots(- [SkillRoot {- path: root.clone(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: Default::default(),- }],+ let outcome = load_and_merge_host_skill_roots(+ vec![HostSkillRoot::host(+ root.clone(),+ SkillScope::User,+ Arc::clone(&LOCAL_FS),+ )],+ &Semaphore::new(/*permits*/ 1),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(1)),).await;@@ -79,18 +76,15 @@ async fn host_catalog_preserves_symlinked_skill_discovery_paths()std::os::unix::fs::symlink(&source_skill_dir, root.path().join("linked-skill"))?;let root = AbsolutePathBuf::try_from(std::fs::canonicalize(root.path())?)?;- let outcome = load_skills_from_roots(- [SkillRoot {- path: root.clone(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: Default::default(),- }],+ let outcome = load_and_merge_host_skill_roots(+ vec![HostSkillRoot::host(+ root.clone(),+ SkillScope::User,+ Arc::clone(&LOCAL_FS),+ )],+ &Semaphore::new(/*permits*/ 1),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(1)),).await;let catalog = catalog_from_outcome(&outcome);diff --git a/codex-rs/ext/skills/src/render_tests.rs b/codex-rs/ext/skills/src/render_tests.rsindex fcc41285b9..9088c1d6e7 100644--- a/codex-rs/ext/skills/src/render_tests.rs+++ b/codex-rs/ext/skills/src/render_tests.rs@@ -6,8 +6,6 @@ use crate::catalog::SkillResourceId;use crate::provider::HostSkillProvider;use crate::provider::SkillListQuery;use crate::provider::SkillProvider;-use codex_core_skills::loader::SkillRoot;-use codex_core_skills::loader::load_skills_from_roots;use codex_exec_server::LOCAL_FS;use codex_extension_api::ContextualUserFragment;use codex_protocol::protocol::SkillScope;@@ -19,6 +17,8 @@ use std::time::UNIX_EPOCH;use tokio::sync::Semaphore;use crate::catalog_prompt::render_available_skills_body;+use crate::loader::HostSkillRoot;+use crate::loader::load_and_merge_host_skill_roots;fn entry(name: &str, description: &str, short_description: Option<&str>) -> SkillCatalogEntry {entry_with_path(@@ -301,29 +301,18 @@ async fn host_alias_roots_follow_core_discovery_order() -> Result<(), Box<dyn st}let user_root = AbsolutePathBuf::try_from(std::fs::canonicalize(&user_root_path)?)?;let system_root = AbsolutePathBuf::try_from(std::fs::canonicalize(&system_root_path)?)?;- let outcome = load_skills_from_roots(- [- SkillRoot {- path: user_root.clone(),- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: Default::default(),- },- SkillRoot {- path: system_root.clone(),- scope: SkillScope::System,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: Default::default(),- },+ let outcome = load_and_merge_host_skill_roots(+ vec![+ HostSkillRoot::host(user_root.clone(), SkillScope::User, Arc::clone(&LOCAL_FS)),+ HostSkillRoot::host(+ system_root.clone(),+ SkillScope::System,+ Arc::clone(&LOCAL_FS),+ ),],+ &Semaphore::new(/*permits*/ 2),+ /*restriction_product*/ None,/*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(2)),).await;let catalog = HostSkillProvider::new()diff --git a/codex-rs/ext/skills/tests/executor_file_system_authority.rs b/codex-rs/ext/skills/tests/executor_file_system_authority.rsindex a53ef44604..fe381a3b36 100644--- a/codex-rs/ext/skills/tests/executor_file_system_authority.rs+++ b/codex-rs/ext/skills/tests/executor_file_system_authority.rs@@ -4,10 +4,10 @@ use std::sync::Arc;use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;-use codex_core_skills::loader::MAX_CONCURRENT_ROOT_SCANS;-use codex_core_skills::loader::SkillRoot;-use codex_core_skills::loader::load_environment_skills_from_root as load_legacy_environment_skills_from_root;-use codex_core_skills::loader::load_skills_from_roots;+use codex_config::ConfigLayerEntry;+use codex_config::ConfigLayerSource;+use codex_config::ConfigLayerStack;+use codex_config::ConfigRequirementsToml;use codex_exec_server::CopyOptions;use codex_exec_server::CreateDirectoryOptions;use codex_exec_server::EnvironmentManager;@@ -25,9 +25,9 @@ use codex_protocol::models::PermissionProfile;use codex_protocol::permissions::FileSystemSandboxPolicy;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_protocol::protocol::Product;-use codex_protocol::protocol::SkillScope;use codex_skills_extension::ExecutorSkillProvider;-use codex_skills_extension::HostSkillsSnapshot;+use codex_skills_extension::HostSkillsLoadInput;+use codex_skills_extension::HostSkillsService;use codex_skills_extension::catalog::SkillAuthority;use codex_skills_extension::catalog::SkillPackageId;use codex_skills_extension::catalog::SkillResourceId;@@ -203,31 +203,47 @@ impl ExecutorFileSystem for SyntheticFileSystem {async fn skill_loading_and_reads_use_the_supplied_executor_file_system() {let test_root =std::env::temp_dir().join(format!("codex-executor-skill-fs-{}", std::process::id()));- let alias_root = AbsolutePathBuf::from_absolute_path_checked(test_root.join("alias"))- .expect("absolute path");+ let project_folder = AbsolutePathBuf::from_absolute_path_checked(test_root.join(".codex"))+ .expect("absolute project folder");+ let alias_root = project_folder.join("skills");let canonical_root = AbsolutePathBuf::from_absolute_path_checked(test_root.join("canonical")).expect("absolute path");assert!(!alias_root.as_path().exists());assert!(!canonical_root.as_path().exists());- let outcome = load_skills_from_roots(- [SkillRoot {- path: alias_root.clone(),- scope: SkillScope::User,- file_system: Arc::new(SyntheticFileSystem {+ let config_layer_stack = ConfigLayerStack::new(+ vec![ConfigLayerEntry::new(+ ConfigLayerSource::Project {+ dot_codex_folder: project_folder,+ },+ toml::Value::Table(Default::default()),+ )],+ Default::default(),+ ConfigRequirementsToml::default(),+ )+ .expect("valid project config stack");+ let cwd = AbsolutePathBuf::from_absolute_path_checked(test_root).expect("absolute test root");+ let service = HostSkillsService::new_with_restriction_product(+ cwd.clone(),+ /*bundled_skills_enabled*/ false,+ /*restriction_product*/ None,+ );+ let snapshot = service+ .snapshot_for_config(+ &HostSkillsLoadInput::new(+ cwd,+ Vec::new(),+ config_layer_stack,+ /*bundled_skills_enabled*/ false,+ ),+ Some(Arc::new(SyntheticFileSystem {alias_root: PathUri::from_abs_path(&alias_root),canonical_root: PathUri::from_abs_path(&canonical_root),has_plugin_manifest: false,- }),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: Default::default(),- }],- /*plugin_skill_snapshots*/ None,- Arc::new(tokio::sync::Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;+ })),+ )+ .await;+ let outcome = snapshot.outcome();assert_eq!(outcome.errors, Vec::new());assert_eq!(outcome.skills.len(), 1);@@ -237,9 +253,8 @@ async fn skill_loading_and_reads_use_the_supplied_executor_file_system() {skill.path_to_skills_md,canonical_root.join("skill/SKILL.md"));- let loaded = HostSkillsSnapshot::new(Arc::new(outcome));assert_eq!(- loaded.read_skill_text(&skill).await.expect("skill body"),+ snapshot.read_skill_text(&skill).await.expect("skill body"),SKILL_CONTENTS);}@@ -441,16 +456,6 @@ async fn executor_discovery_routes_produce_equivalent_catalog_metadata() {executor_capability_discovery,};- let legacy_file_system = manager- .get_environment("local")- .expect("local environment")- .get_filesystem();- let legacy = load_legacy_environment_skills_from_root(- legacy_file_system.as_ref(),- &PathUri::from_host_native_path(&test_root).expect("skill root URI"),- Some(Product::Codex),- )- .await;let direct = provider.list(query(None)).await@@ -484,36 +489,8 @@ async fn executor_discovery_routes_produce_equivalent_catalog_metadata() {.collect::<Vec<_>>()};assert_eq!(comparable_entries(&bundled), comparable_entries(&direct));- assert_eq!(legacy.warnings, direct.warnings);assert_eq!(direct.warnings.len(), 1);assert!(direct.warnings[0].contains("missing field `description`"));- let legacy_metadata = legacy- .skills- .iter()- .map(|skill| {- (- skill.name.clone(),- skill.description.clone(),- skill.short_description.clone(),- skill.dependencies.clone(),- skill.allows_implicit_invocation(),- )- })- .collect::<Vec<_>>();- let catalog_metadata = direct- .entries- .iter()- .map(|entry| {- (- entry.name.clone(),- entry.description.clone(),- entry.short_description.clone(),- entry.dependencies.clone(),- entry.prompt_visible,- )- })- .collect::<Vec<_>>();- assert_eq!(catalog_metadata, legacy_metadata);let entry = direct.entries.iter()@@ -692,16 +669,6 @@ async fn direct_executor_discovery_preserves_hidden_nested_and_probed_metadata()},};let manager = Arc::new(EnvironmentManager::default_for_tests());- let legacy_file_system = manager- .get_environment("local")- .expect("local environment")- .get_filesystem();- let legacy = load_legacy_environment_skills_from_root(- legacy_file_system.as_ref(),- &root_uri,- /*restriction_product*/ None,- )- .await;let provider = ExecutorSkillProvider::new_with_restriction_product(manager, /*restriction_product*/ None,);@@ -720,18 +687,7 @@ async fn direct_executor_discovery_preserves_hidden_nested_and_probed_metadata().await.expect("list directly discovered executor skills");- assert_eq!(direct.warnings, legacy.warnings);- let legacy_metadata = legacy- .skills- .iter()- .map(|skill| {- (- skill.name.clone(),- skill.description.clone(),- skill.allows_implicit_invocation(),- )- })- .collect::<Vec<_>>();+ assert_eq!(direct.warnings, Vec::<String>::new());let catalog_metadata = direct.entries.iter()@@ -743,7 +699,6 @@ async fn direct_executor_discovery_preserves_hidden_nested_and_probed_metadata())}).collect::<Vec<_>>();- assert_eq!(catalog_metadata, legacy_metadata);assert_eq!(catalog_metadata,vec![diff --git a/codex-rs/ext/skills/tests/skills_extension.rs b/codex-rs/ext/skills/tests/skills_extension.rsindex 6dfb938576..9e6b1ee925 100644--- a/codex-rs/ext/skills/tests/skills_extension.rs+++ b/codex-rs/ext/skills/tests/skills_extension.rs@@ -4,11 +4,10 @@ use std::sync::Mutex;use std::sync::atomic::AtomicUsize;use std::sync::atomic::Ordering;+use codex_config::ConfigLayerStack;+use codex_config::ConfigRequirementsToml;use codex_core_skills::SkillLoadOutcome;use codex_core_skills::injection::InjectedHostSkillPrompts;-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_exec_server::LOCAL_FS;use codex_extension_api::ConversationHistory;use codex_extension_api::ExtensionData;@@ -44,6 +43,8 @@ use codex_protocol::protocol::TurnEnvironmentSelection;use codex_protocol::user_input::UserInput;use codex_skills::SkillMetadata;use codex_skills_extension::HostSkillProvider;+use codex_skills_extension::HostSkillsLoadInput;+use codex_skills_extension::HostSkillsService;use codex_skills_extension::HostSkillsSnapshot;use codex_skills_extension::SkillProviders;use codex_skills_extension::SkillsExtensionConfig;@@ -70,7 +71,6 @@ use opentelemetry_sdk::metrics::InMemoryMetricExporter;use opentelemetry_sdk::metrics::data::AggregatedMetrics;use opentelemetry_sdk::metrics::data::MetricData;use pretty_assertions::assert_eq;-use tokio::sync::Semaphore;type TestResult = Result<(), Box<dyn std::error::Error>>;@@ -1876,22 +1876,34 @@ async fn host_catalog_compacts_shared_paths_under_budget_pressure() -> TestResul}let root = AbsolutePathBuf::try_from(std::fs::canonicalize(root)?)?;let rendered_root = root.to_string_lossy().replace('\\', "/");- let outcome = load_skills_from_roots(- [SkillRoot {- path: root,- scope: SkillScope::User,- file_system: Arc::clone(&LOCAL_FS),- plugin_identity: None,- plugin_namespace: None,- plugin_root: None,- discovery_mode: Default::default(),- }],- /*plugin_skill_snapshots*/ None,- Arc::new(Semaphore::new(MAX_CONCURRENT_ROOT_SCANS)),- )- .await;- assert_eq!(outcome.errors, Vec::new());- assert_eq!(outcome.skills.len(), 12 + usize::from(cfg!(unix)));+ let config_layer_stack = ConfigLayerStack::new(+ Vec::new(),+ Default::default(),+ ConfigRequirementsToml::default(),+ )?;+ let codex_home = AbsolutePathBuf::try_from(test_root.clone())?;+ let service = HostSkillsService::new_with_restriction_product(+ codex_home.clone(),+ /*bundled_skills_enabled*/ false,+ /*restriction_product*/ None,+ );+ service.set_extra_roots(vec![root]);+ let snapshot = service+ .snapshot_for_config(+ &HostSkillsLoadInput::new(+ codex_home,+ Vec::new(),+ config_layer_stack,+ /*bundled_skills_enabled*/ false,+ ),+ Some(Arc::clone(&LOCAL_FS)),+ )+ .await;+ assert_eq!(snapshot.outcome().errors, Vec::new());+ assert_eq!(+ snapshot.outcome().skills.len(),+ 12 + usize::from(cfg!(unix))+ );let mut builder = ExtensionRegistryBuilder::new();install(&mut builder, skills_extension_config);@@ -1916,7 +1928,7 @@ async fn host_catalog_compacts_shared_paths_under_budget_pressure() -> TestResulmodel_info.context_window = Some(10_000);thread_store.insert(model_info);let turn_store = ExtensionData::new("turn-1");- turn_store.insert(HostSkillsSnapshot::new(Arc::new(outcome)));+ turn_store.insert(snapshot);let fragments = registry.turn_input_contributors()[0].contribute(diff --git a/codex-rs/skills/src/parser_tests.rs b/codex-rs/skills/src/parser_tests.rsindex 2bbad1e2c0..d0fe46c679 100644--- a/codex-rs/skills/src/parser_tests.rs+++ b/codex-rs/skills/src/parser_tests.rs@@ -41,3 +41,79 @@ fn uses_default_name_and_requires_description() {.expect_err("description should be required");assert_eq!(error.to_string(), "missing field `description`");}++#[test]+fn repairs_short_descriptions_containing_colons_and_apostrophes() {+ let parsed = parse_skill_frontmatter_metadata(+ "---\nname: short\ndescription: Short skill\nmetadata:\n short-description: What's included: builds and tests\n---\n",+ || "fallback".to_string(),+ )+ .expect("frontmatter with an unquoted short description should be repaired");++ assert_eq!(+ parsed,+ ParsedSkillFrontmatter {+ name: "short".to_string(),+ description: "Short skill".to_string(),+ short_description: Some("What's included: builds and tests".to_string()),+ }+ );+}++#[test]+fn repairs_unrecognized_frontmatter_fields_that_need_quotes() {+ let parsed = parse_skill_frontmatter_metadata(+ "---\nname: unknown\ndescription: Unknown fields\nargument-hint: <duration: e.g. 7d, 2w>\ntags: [next,@supabase/ssr]\n---\n",+ || "fallback".to_string(),+ )+ .expect("frontmatter with unrecognized fields should be repaired");++ assert_eq!(+ parsed,+ ParsedSkillFrontmatter {+ name: "unknown".to_string(),+ description: "Unknown fields".to_string(),+ short_description: None,+ }+ );+}++#[test]+fn preserves_block_scalar_bodies_while_repairing_other_fields() {+ let parsed = parse_skill_frontmatter_metadata(+ "---\nname: block\ndescription: |-\n Build for AWS: ECS\nargument-hint: <duration: e.g. 7d>\n---\n",+ || "fallback".to_string(),+ )+ .expect("frontmatter repair should preserve block scalar bodies");++ assert_eq!(+ parsed,+ ParsedSkillFrontmatter {+ name: "block".to_string(),+ description: "Build for AWS: ECS".to_string(),+ short_description: None,+ }+ );+}++#[test]+fn preserves_overlong_descriptions_and_short_descriptions() {+ let description = "💡".repeat(/*n*/ 1_025);+ let short_description = "x".repeat(/*n*/ 1_025);+ let parsed = parse_skill_frontmatter_metadata(+ &format!(+ "---\nname: long\ndescription: {description}\nmetadata:\n short-description: {short_description}\n---\n"+ ),+ || "fallback".to_string(),+ )+ .expect("descriptions should not be truncated during frontmatter parsing");++ assert_eq!(+ parsed,+ ParsedSkillFrontmatter {+ name: "long".to_string(),+ description,+ short_description: Some(short_description),+ }+ );+}