Remove skills list extra roots

codex-rs/app-server-protocol/src/protocol/common.rs

@@ -1664,7 +1664,6 @@ mod tests {
             params: v2::SkillsListParams {
                 cwds: Vec::new(),
                 force_reload: false,
-                per_cwd_extra_user_roots: None,
             },
         };
         assert_eq!(
@@ -1674,7 +1673,10 @@ mod tests {
 
         let plugin_list = ClientRequest::PluginList {
             request_id: request_id(),
-            params: v2::PluginListParams { cwds: None },
+            params: v2::PluginListParams {
+                cwds: None,
+                marketplace_kinds: None,
+            },
         };
         assert_eq!(
             plugin_list.serialization_scope(),

codex-rs/app-server-protocol/src/protocol/v2/plugin.rs

@@ -15,7 +15,7 @@ use serde::Serialize;
 use std::path::PathBuf;
 use ts_rs::TS;
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct SkillsListParams {
@@ -26,19 +26,6 @@ pub struct SkillsListParams {
     /// When true, bypass the skills cache and re-scan skills from disk.
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub force_reload: bool,
-
-    /// Optional per-cwd extra roots to scan as user-scoped skills.
-    #[serde(default)]
-    #[ts(optional = nullable)]
-    pub per_cwd_extra_user_roots: Option<Vec<SkillsListExtraRootsForCwd>>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct SkillsListExtraRootsForCwd {
-    pub cwd: PathBuf,
-    pub extra_user_roots: Vec<PathBuf>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]

codex-rs/app-server-protocol/src/protocol/v2/tests.rs

@@ -2627,33 +2627,20 @@ fn skills_list_params_serialization_uses_force_reload() {
         serde_json::to_value(SkillsListParams {
             cwds: Vec::new(),
             force_reload: false,
-            per_cwd_extra_user_roots: None,
         })
         .unwrap(),
-        json!({
-            "perCwdExtraUserRoots": null,
-        }),
+        json!({}),
     );
 
     assert_eq!(
         serde_json::to_value(SkillsListParams {
             cwds: vec![PathBuf::from("/repo")],
             force_reload: true,
-            per_cwd_extra_user_roots: Some(vec![SkillsListExtraRootsForCwd {
-                cwd: PathBuf::from("/repo"),
-                extra_user_roots: vec![PathBuf::from("/shared/skills"), PathBuf::from("/tmp/x")],
-            }]),
         })
         .unwrap(),
         json!({
             "cwds": ["/repo"],
             "forceReload": true,
-            "perCwdExtraUserRoots": [
-                {
-                    "cwd": "/repo",
-                    "extraUserRoots": ["/shared/skills", "/tmp/x"],
-                }
-            ],
         }),
     );
 }

codex-rs/app-server/README.md

@@ -1473,21 +1473,13 @@ $skill-creator Add a new skill for triaging flaky CI and include step-by-step us
 ```
 
 Use `skills/list` to fetch the available skills (optionally scoped by `cwds`, with `forceReload`).
-You can also add `perCwdExtraUserRoots` to scan additional absolute paths as `user` scope for specific `cwd` entries.
-Entries whose `cwd` is not present in `cwds` are ignored.
 `skills/list` might reuse a cached skills result per `cwd`; setting `forceReload` to `true` refreshes the result from disk.
 The server also emits `skills/changed` notifications when watched local skill files change. Treat this as an invalidation signal and re-run `skills/list` with your current params when needed.
 
 ```json
 { "method": "skills/list", "id": 25, "params": {
     "cwds": ["/Users/me/project", "/Users/me/other-project"],
-    "forceReload": true,
-    "perCwdExtraUserRoots": [
-      {
-        "cwd": "/Users/me/project",
-        "extraUserRoots": ["/Users/me/shared-skills"]
-      }
-    ]
+    "forceReload": true
 } }
 { "id": 25, "result": {
     "data": [{

codex-rs/app-server/src/request_processors/catalog_processor.rs

@@ -382,44 +382,12 @@ impl CatalogRequestProcessor {
         &self,
         params: SkillsListParams,
     ) -> Result<SkillsListResponse, JSONRPCErrorError> {
-        let SkillsListParams {
-            cwds,
-            force_reload,
-            per_cwd_extra_user_roots,
-        } = params;
+        let SkillsListParams { cwds, force_reload } = params;
         let cwds = if cwds.is_empty() {
             vec![self.config.cwd.to_path_buf()]
         } else {
             cwds
         };
-        let cwd_set: HashSet<PathBuf> = cwds.iter().cloned().collect();
-
-        let mut extra_roots_by_cwd: HashMap<PathBuf, Vec<AbsolutePathBuf>> = HashMap::new();
-        for entry in per_cwd_extra_user_roots.unwrap_or_default() {
-            if !cwd_set.contains(&entry.cwd) {
-                warn!(
-                    cwd = %entry.cwd.display(),
-                    "ignoring per-cwd extra roots for cwd not present in skills/list cwds"
-                );
-                continue;
-            }
-
-            let mut valid_extra_roots = Vec::new();
-            for root in entry.extra_user_roots {
-                let root =
-                    AbsolutePathBuf::from_absolute_path_checked(root.as_path()).map_err(|_| {
-                        invalid_request(format!(
-                            "skills/list perCwdExtraUserRoots extraUserRoots paths must be absolute: {}",
-                            root.display()
-                        ))
-                    })?;
-                valid_extra_roots.push(root);
-            }
-            extra_roots_by_cwd
-                .entry(entry.cwd)
-                .or_default()
-                .extend(valid_extra_roots);
-        }
 
         let config = self.load_latest_config(/*fallback_cwd*/ None).await?;
         let auth = self.auth_manager.auth().await;
@@ -436,7 +404,6 @@ impl CatalogRequestProcessor {
         let mut data = futures::stream::iter(cwds.into_iter().enumerate())
             .map(|(index, cwd)| {
                 let config = &config;
-                let extra_roots_by_cwd = &extra_roots_by_cwd;
                 let fs = fs.clone();
                 let plugins_manager = &plugins_manager;
                 let skills_manager = &skills_manager;
@@ -458,9 +425,6 @@ impl CatalogRequestProcessor {
                             );
                         }
                     };
-                    let extra_roots = extra_roots_by_cwd
-                        .get(&cwd)
-                        .map_or(&[][..], std::vec::Vec::as_slice);
                     let effective_skill_roots = if workspace_codex_plugins_enabled {
                         let plugins_input = config.plugins_config_input();
                         plugins_manager
@@ -479,12 +443,7 @@ impl CatalogRequestProcessor {
                         config.bundled_skills_enabled(),
                     );
                     let outcome = skills_manager
-                        .skills_for_cwd_with_extra_user_roots(
-                            &skills_input,
-                            force_reload,
-                            extra_roots,
-                            fs,
-                        )
+                        .skills_for_cwd(&skills_input, force_reload, fs)
                         .await;
                     let errors = errors_to_info(&outcome.errors);
                     let skills = skills_to_info(&outcome.skills, &outcome.disabled_paths);