alphaXiv
diff --git a/‎src/commands/up.rs‎
Lines changed: 26 additions & 129 deletions b/‎src/commands/up.rs‎
Lines changed: 26 additions & 129 deletions
diff --git a/‎src/local/chat/mod.rs‎
Lines changed: 1 addition & 3 deletions b/‎src/local/chat/mod.rs‎
Lines changed: 1 addition & 3 deletions
diff --git a/‎src/local/harness/claude.rs‎
Lines changed: 89 additions & 0 deletions b/‎src/local/harness/claude.rs‎
Lines changed: 89 additions & 0 deletions
diff --git a/‎src/local/harness/mod.rs‎
Lines changed: 8 additions & 0 deletions b/‎src/local/harness/mod.rs‎
Lines changed: 8 additions & 0 deletions
@@ -441,8 +441,6 @@ fn router(state: AppState) -> Router {
                 .post(upload_user_skill)
                 .delete(delete_user_skill),
         )
-        .route("/api/user-skills/import", post(import_user_skill))
-        .route("/api/harness-skills", get(list_harness_skills))
         .route(
             "/api/latex-templates",
             get(list_latex_templates)
@@ -693,14 +691,14 @@ async fn complete_onboarding(
 
 #[derive(Deserialize)]
 struct SkillsQ {
-    /// Include the project's own uploaded skills (plus globals) in the menu.
+    /// The open project, so a built-in skill's instructions can account for it.
     project: Option<String>,
 }
 
 /// Slash-skills the composer's `/` dropdown offers (expanded server-side): the
-/// built-in catalog plus any user-uploaded skills that apply (globals, and the
-/// named project's own).
-async fn list_skills(Query(q): Query<SkillsQ>) -> Json<Value> {
+/// built-in catalog plus the user's own — uploaded here or mirrored from a
+/// coding agent.
+async fn list_skills() -> Json<Value> {
     let mut skills: Vec<Value> = crate::local::skills::CATALOG
         .iter()
         .map(|s| {
@@ -711,16 +709,7 @@ async fn list_skills(Query(q): Query<SkillsQ>) -> Json<Value> {
             })
         })
         .collect();
-    // One `/name` per skill: a project skill shadows a same-named global
-    // (list_for_project returns globals first, then the project's own).
-    let mut user: Vec<crate::local::user_skills::UserSkill> = Vec::new();
-    for s in crate::local::user_skills::list_for_project(q.project.as_deref()) {
-        match user.iter_mut().find(|e| e.name == s.name) {
-            Some(existing) => *existing = s,
-            None => user.push(s),
-        }
-    }
-    for s in user {
+    for s in crate::local::user_skills::list() {
         skills.push(json!({
             "name": s.name,
             "description": s.description,
@@ -745,58 +734,25 @@ async fn get_skill(Path(name): Path<String>, Query(q): Query<SkillsQ>) -> ApiRes
     if let Some(content) = crate::local::skills::instructions(&name, false, github_enabled) {
         return Ok(Json(json!({ "name": name, "content": content })));
     }
-    let content = crate::local::user_skills::content(&name, q.project.as_deref())
-        .ok_or_else(|| not_found("skill"))?;
+    let content = crate::local::user_skills::content(&name).ok_or_else(|| not_found("skill"))?;
     Ok(Json(json!({ "name": name, "content": content })))
 }
 
-// --- user-uploaded skills -----------------------------------------------------
-
-fn parse_scope(scope: &str) -> std::result::Result<crate::local::user_skills::Scope, ApiError> {
-    match scope {
-        "global" => Ok(crate::local::user_skills::Scope::Global),
-        "project" => Ok(crate::local::user_skills::Scope::Project),
-        other => Err(bad_request(format!("unknown scope `{other}`"))),
-    }
-}
+// --- user skills --------------------------------------------------------------
 
 fn user_skill_json(s: &crate::local::user_skills::UserSkill) -> Value {
     json!({
         "name": s.name,
-        "description": s.description,
-        "scope": s.scope,
+        "origin": s.origin,
         "bytes": s.bytes,
         "updatedAt": s.updated_at,
     })
 }
 
-/// Resolve the target scope and validate the project exists for project scope.
-fn resolve_skill_scope(
-    scope: crate::local::user_skills::Scope,
-    project_id: Option<&str>,
-) -> std::result::Result<Option<String>, ApiError> {
-    match scope {
-        crate::local::user_skills::Scope::Global => Ok(None),
-        crate::local::user_skills::Scope::Project => {
-            let id = project_id
-                .filter(|s| !s.is_empty())
-                .ok_or_else(|| bad_request("project scope requires a projectId"))?;
-            Store::open()?
-                .get_local_project(id)?
-                .ok_or_else(|| not_found("project"))?;
-            Ok(Some(id.to_string()))
-        }
-    }
-}
-
-#[derive(Deserialize)]
-struct UserSkillsListQ {
-    project: Option<String>,
-}
-
-/// Both scopes for the Customize tab: globals plus the project's own.
-async fn list_user_skills(Query(q): Query<UserSkillsListQ>) -> ApiResult {
-    let skills: Vec<Value> = crate::local::user_skills::list_for_project(q.project.as_deref())
+/// Everything the Customize tab lists: uploads plus the skills mirrored from the
+/// coding agents installed on this machine.
+async fn list_user_skills() -> ApiResult {
+    let skills: Vec<Value> = crate::local::user_skills::list()
         .iter()
         .map(user_skill_json)
         .collect();
@@ -806,26 +762,22 @@ async fn list_user_skills(Query(q): Query<UserSkillsListQ>) -> ApiResult {
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct UploadSkillReq {
-    scope: String,
-    project_id: Option<String>,
     /// Original upload filename — its extension picks `.zip` vs single file.
     filename: String,
     /// The file bytes, base64 (same convention as chat attachments).
     content_base64: String,
 }
 
 async fn upload_user_skill(Json(req): Json<UploadSkillReq>) -> ApiResult {
-    let scope = parse_scope(&req.scope)?;
-    let project = resolve_skill_scope(scope, req.project_id.as_deref())?;
     let bytes = base64::engine::general_purpose::STANDARD
         .decode(req.content_base64.trim())
         .map_err(|e| bad_request(format!("invalid file data: {e}")))?;
 
     let lower = req.filename.to_ascii_lowercase();
     let saved = if lower.ends_with(".zip") {
-        crate::local::user_skills::save_zip(&bytes, scope, project.as_deref())
+        crate::local::user_skills::save_zip(&bytes)
     } else if lower.ends_with(".md") || lower.ends_with(".markdown") {
-        crate::local::user_skills::save_skill_md(&bytes, scope, project.as_deref())
+        crate::local::user_skills::save_skill_md(&bytes)
     } else {
         return Err(bad_request(
             "upload a SKILL.md file or a .zip of a skill folder",
@@ -837,102 +789,47 @@ async fn upload_user_skill(Json(req): Json<UploadSkillReq>) -> ApiResult {
 }
 
 #[derive(Deserialize)]
-struct DeleteSkillQ {
-    scope: String,
+struct DeleteByNameQ {
     name: String,
-    project: Option<String>,
 }
 
-async fn delete_user_skill(Query(q): Query<DeleteSkillQ>) -> ApiResult {
-    let scope = parse_scope(&q.scope)?;
-    let project = resolve_skill_scope(scope, q.project.as_deref())?;
-    crate::local::user_skills::delete(&q.name, scope, project.as_deref()).map_err(bad_request)?;
+async fn delete_user_skill(Query(q): Query<DeleteByNameQ>) -> ApiResult {
+    crate::local::user_skills::delete(&q.name).map_err(bad_request)?;
     Ok(Json(json!({ "ok": true })))
 }
 
 fn latex_template_json(t: &crate::local::latex_templates::LatexTemplate) -> Value {
     json!({
         "name": t.name,
-        "scope": t.scope,
         "entry": t.entry,
         "supportFiles": t.support_files,
         "bytes": t.bytes,
         "updatedAt": t.updated_at,
     })
 }
 
-/// Both scopes for the Customize tab's templates card.
-async fn list_latex_templates(Query(q): Query<UserSkillsListQ>) -> ApiResult {
-    let templates: Vec<Value> =
-        crate::local::latex_templates::list_for_project(q.project.as_deref())
-            .iter()
-            .map(latex_template_json)
-            .collect();
+async fn list_latex_templates() -> ApiResult {
+    let templates: Vec<Value> = crate::local::latex_templates::list()
+        .iter()
+        .map(latex_template_json)
+        .collect();
     Ok(Json(json!({ "templates": templates })))
 }
 
 async fn upload_latex_template(Json(req): Json<UploadSkillReq>) -> ApiResult {
-    let scope = parse_scope(&req.scope)?;
-    let project = resolve_skill_scope(scope, req.project_id.as_deref())?;
     let bytes = base64::engine::general_purpose::STANDARD
         .decode(req.content_base64.trim())
         .map_err(|e| bad_request(format!("invalid file data: {e}")))?;
-    let saved = crate::local::latex_templates::save_upload(
-        &req.filename,
-        &bytes,
-        scope,
-        project.as_deref(),
-    )
-    .map_err(bad_request)?;
+    let saved =
+        crate::local::latex_templates::save_upload(&req.filename, &bytes).map_err(bad_request)?;
     Ok(Json(json!({ "template": latex_template_json(&saved) })))
 }
 
-async fn delete_latex_template(Query(q): Query<DeleteSkillQ>) -> ApiResult {
-    let scope = parse_scope(&q.scope)?;
-    let project = resolve_skill_scope(scope, q.project.as_deref())?;
-    crate::local::latex_templates::delete(&q.name, scope, project.as_deref())
-        .map_err(bad_request)?;
+async fn delete_latex_template(Query(q): Query<DeleteByNameQ>) -> ApiResult {
+    crate::local::latex_templates::delete(&q.name).map_err(bad_request)?;
     Ok(Json(json!({ "ok": true })))
 }
 
-/// Skills already installed in the user's coding agents, offered for import.
-async fn list_harness_skills() -> ApiResult {
-    let skills: Vec<Value> = crate::local::user_skills::list_harness_skills()
-        .iter()
-        .map(|s| {
-            json!({
-                "harnessId": s.harness_id,
-                "harnessName": s.harness_name,
-                "name": s.name,
-                "description": s.description,
-            })
-        })
-        .collect();
-    Ok(Json(json!({ "skills": skills })))
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct ImportSkillReq {
-    harness: String,
-    name: String,
-    scope: String,
-    project_id: Option<String>,
-}
-
-async fn import_user_skill(Json(req): Json<ImportSkillReq>) -> ApiResult {
-    let scope = parse_scope(&req.scope)?;
-    let project = resolve_skill_scope(scope, req.project_id.as_deref())?;
-    let saved = crate::local::user_skills::import_from_harness(
-        &req.harness,
-        &req.name,
-        scope,
-        project.as_deref(),
-    )
-    .map_err(bad_request)?;
-    Ok(Json(json!({ "skill": user_skill_json(&saved) })))
-}
-
 /// Serialize a project for the UI, injecting the absolute artifacts directory
 /// so the dashboard can recognize artifact paths in chat links. `filesDir` is
 /// retained as a compatibility alias for older clients. Every project the UI
 
@@ -1910,9 +1910,7 @@ fn selected_slash_skills(project: &LocalProject, text: &str) -> (Vec<SelectedSla
                     instructions,
                 });
             }
-        } else if let Some(instructions) =
-            crate::local::user_skills::instructions(&name, &project.id)
-        {
+        } else if let Some(instructions) = crate::local::user_skills::instructions(&name) {
             seen.insert(name);
             selected.push(SelectedSlashSkill::User { instructions });
         }
 
@@ -741,6 +741,55 @@ impl Harness for ClaudeCode {
     fn session_skills_dir(&self) -> Option<&'static str> {
         Some(".claude/skills")
     }
+
+    fn plugin_skills_dirs(&self) -> Vec<(String, PathBuf)> {
+        self.config_home()
+            .map(|home| installed_plugin_skills_dirs(&home))
+            .unwrap_or_default()
+    }
+}
+
+/// The `skills/` dir of every plugin installed in Claude Code, labeled with the
+/// plugin's own name. Keyed off `installed_plugins.json`, whose `installPath` is
+/// the only thing that knows whether an install resolved to the version cache or
+/// a marketplace checkout — and which of the marketplace's plugins are actually
+/// installed rather than merely on offer.
+fn installed_plugin_skills_dirs(config_home: &Path) -> Vec<(String, PathBuf)> {
+    let manifest = config_home.join("plugins").join("installed_plugins.json");
+    let Ok(text) = std::fs::read_to_string(&manifest) else {
+        return Vec::new();
+    };
+    let Ok(json) = serde_json::from_str::<Value>(&text) else {
+        return Vec::new();
+    };
+    let Some(plugins) = json.get("plugins").and_then(|v| v.as_object()) else {
+        return Vec::new();
+    };
+    let mut out: Vec<(String, PathBuf)> = Vec::new();
+    for (key, installs) in plugins {
+        // Keys are `<plugin>@<marketplace>`, and a plugin name can itself be
+        // scoped (`@acme/tools@market`) — so the marketplace is the last `@`.
+        let label = key.rsplit_once('@').map_or(key.as_str(), |(name, _)| name);
+        let Some(installs) = installs.as_array() else {
+            continue;
+        };
+        for install in installs {
+            let Some(path) = install.get("installPath").and_then(|v| v.as_str()) else {
+                continue;
+            };
+            let dir = PathBuf::from(path).join("skills");
+            // Only absolute installs; a relative path would resolve against the
+            // server's working dir, which is not what the manifest meant.
+            if dir.is_absolute()
+                && dir.is_dir()
+                && !out.iter().any(|(_, existing)| *existing == dir)
+            {
+                out.push((label.to_string(), dir));
+            }
+        }
+    }
+    out.sort();
+    out
 }
 
 /// Internal policy → Claude Code `--permission-mode` value. Each provider-owned
@@ -2051,6 +2100,46 @@ mod tests {
     use super::super::options::REASONING_DEFAULT_ID;
     use super::*;
 
+    /// Plugins live in the version cache or a marketplace checkout, and a
+    /// marketplace holds plugins that are merely on offer — so only the
+    /// `installPath` of an actual install counts, and only when it ships skills.
+    #[test]
+    fn plugin_skills_dirs_follow_the_install_manifest() {
+        let home = std::env::temp_dir().join(format!("orx-plugins-test-{}", uuid::Uuid::new_v4()));
+        let installed = home.join("cache/runpod/runpod/1.2.0");
+        let scoped = home.join("cache/market/acme-tools/0.2.0");
+        let no_skills = home.join("cache/other/other/0.1.0");
+        std::fs::create_dir_all(installed.join("skills/flash")).expect("mkdir");
+        std::fs::create_dir_all(scoped.join("skills/lint")).expect("mkdir");
+        std::fs::create_dir_all(&no_skills).expect("mkdir");
+        std::fs::create_dir_all(home.join("plugins")).expect("mkdir");
+        std::fs::write(
+            home.join("plugins/installed_plugins.json"),
+            serde_json::json!({
+                "version": 2,
+                "plugins": {
+                    "runpod@runpod": [{"installPath": installed.to_string_lossy(), "version": "1.2.0"}],
+                    "@acme/tools@market": [{"installPath": scoped.to_string_lossy()}],
+                    "skill-less@market": [{"installPath": no_skills.to_string_lossy()}],
+                },
+            })
+            .to_string(),
+        )
+        .expect("write");
+
+        assert_eq!(
+            installed_plugin_skills_dirs(&home),
+            vec![
+                // A plugin name can itself be scoped: the marketplace is the last `@`.
+                ("@acme/tools".to_string(), scoped.join("skills")),
+                ("runpod".to_string(), installed.join("skills")),
+            ]
+        );
+        // No manifest at all is no plugins, not an error.
+        assert!(installed_plugin_skills_dirs(&home.join("nope")).is_empty());
+        let _ = std::fs::remove_dir_all(&home);
+    }
+
     /// A `list_models` response in the live 2.1.212 shape (fields we don't
     /// read trimmed). Covers the four things the parser decides: the `default`
     /// entry is skipped, `value` (the alias the CLI's own picker submits) is
 
@@ -369,6 +369,14 @@ pub trait Harness: Send + Sync {
         Some(self.skill_target()?.parent()?.parent()?.to_path_buf())
     }
 
+    /// Further skills dirs this agent loads from, each labeled by where it came
+    /// from — the plugins installed into this agent. Same shape as
+    /// [`global_skills_dir`](Self::global_skills_dir): one skill folder per
+    /// entry. Default: none.
+    fn plugin_skills_dirs(&self) -> Vec<(String, PathBuf)> {
+        Vec::new()
+    }
+
     // --- session-skills capability ----------------------------------------
 
     /// The worktree-relative dir this harness discovers native `SKILL.md` skill
Original file line number	Diff line number	Diff line change
`@@ -1910,9 +1910,7 @@ fn selected_slash_skills(project: &LocalProject, text: &str) -> (Vec<SelectedSla`
`1910`	`1910`	`instructions,`
`1911`	`1911`	`});`
`1912`	`1912`	`}`
`1913`		`- } else if let Some(instructions) =`
`1914`		`- crate::local::user_skills::instructions(&name, &project.id)`
`1915`		`- {`
	`1913`	`+ } else if let Some(instructions) = crate::local::user_skills::instructions(&name) {`
`1916`	`1914`	`seen.insert(name);`
`1917`	`1915`	`selected.push(SelectedSlashSkill::User { instructions });`
`1918`	`1916`	`}`