refactor(skills): isolate builtin skills and centralize mode skill resolution

Cargo.toml

@@ -77,6 +77,7 @@ dirs = "5.0"
 dark-light = "1.1"
 dunce = "1"
 filetime = "0.2"
+fs2 = "0.4"
 zip = "0.6" # plugin load
 flate2 = "1.0"
 toml = "0.8"

src/apps/desktop/src/api/skill_api.rs

@@ -17,13 +17,12 @@ use tokio::time::{timeout, Duration};
 
 use crate::api::app_state::AppState;
 use bitfun_core::agentic::tools::implementations::skills::mode_overrides::{
-    get_disabled_mode_skills_from_document, load_project_mode_skills_document_local,
-    load_user_mode_skill_overrides, project_mode_skills_path_for_remote,
+    load_project_mode_skills_document_local, project_mode_skills_path_for_remote,
     save_project_mode_skills_document_local, set_disabled_mode_skills_in_document,
     set_mode_skill_disabled_in_document, set_user_mode_skill_state,
 };
 use bitfun_core::agentic::tools::implementations::skills::{
-    default_profiles::{is_enabled_by_default_for_mode, is_skill_enabled_for_mode},
+    resolver::resolve_skill_default_enabled_for_mode,
     ModeSkillInfo, SkillData, SkillInfo, SkillLocation, SkillRegistry,
 };
 use bitfun_core::agentic::workspace::RemoteWorkspaceFs;
@@ -191,87 +190,26 @@ async fn get_mode_skill_infos_for_workspace_input(
     mode_id: &str,
     workspace_path: Option<&str>,
 ) -> Result<Vec<ModeSkillInfo>, String> {
-    let all_skills = get_all_skills_for_workspace_input(state, registry, workspace_path).await?;
-    let user_overrides = load_user_mode_skill_overrides(mode_id)
-        .await
-        .map_err(|e| format!("Failed to load user skill overrides: {}", e))?;
-
-    let (disabled_project, resolved_skills): (HashSet<String>, Vec<SkillInfo>) = if let Some((
-        remote_root,
-        entry,
-    )) =
-        resolve_remote_workspace(state, workspace_path).await?
-    {
+    if let Some((remote_root, entry)) = resolve_remote_workspace(state, workspace_path).await? {
         let remote_fs = state
             .get_remote_file_service_async()
             .await
             .map_err(|e| format!("Remote file service not available: {}", e))?;
         let remote_workspace_fs =
             RemoteWorkspaceFs::new(entry.connection_id.clone(), remote_fs.clone());
-        let project_config_path = project_mode_skills_path_for_remote(&remote_root);
-        let project_config = if remote_fs
-            .exists(&entry.connection_id, &project_config_path)
-            .await
-            .map_err(|e| format!("Failed to check remote project skill overrides: {}", e))?
-        {
-            let content = remote_fs
-                .read_file(&entry.connection_id, &project_config_path)
-                .await
-                .map_err(|e| format!("Failed to read remote project skill overrides: {}", e))?;
-            let content = String::from_utf8(content).map_err(|e| {
-                format!("Remote project skill overrides are not valid UTF-8: {}", e)
-            })?;
-            serde_json::from_str::<Value>(&content)
-                .map_err(|e| format!("Invalid remote project skill overrides JSON: {}", e))?
-        } else {
-            serde_json::json!({})
-        };
-
-        (
-            get_disabled_mode_skills_from_document(&project_config, mode_id)
-                .into_iter()
-                .collect(),
-            registry
-                .get_resolved_skills_for_remote_workspace(
-                    &remote_workspace_fs,
-                    &remote_root,
-                    Some(mode_id),
-                )
-                .await,
-        )
+        Ok(registry
+            .get_mode_skill_infos_for_remote_workspace(&remote_workspace_fs, &remote_root, mode_id)
+            .await)
+    } else if let Some(workspace_root) = workspace_root_from_input(workspace_path) {
+        Ok(registry
+            .get_mode_skill_infos_for_workspace(Some(&workspace_root), mode_id)
+            .await)
     } else {
-        let workspace_root = workspace_root_from_input(workspace_path)
-            .ok_or_else(|| "Project-level skill overrides require an open workspace".to_string())?;
-        let project_config = load_project_mode_skills_document_local(&workspace_root)
-            .await
-            .map_err(|e| format!("Failed to load project mode skills: {}", e))?;
-        (
-            get_disabled_mode_skills_from_document(&project_config, mode_id)
-                .into_iter()
-                .collect(),
-            registry
-                .get_resolved_skills_for_workspace(Some(&workspace_root), Some(mode_id))
-                .await,
-        )
-    };
-
-    let resolved_keys: HashSet<String> =
-        resolved_skills.into_iter().map(|skill| skill.key).collect();
-
-    Ok(all_skills
-        .into_iter()
-        .map(|skill| {
-            let disabled_by_mode =
-                !is_skill_enabled_for_mode(&skill, mode_id, &user_overrides, &disabled_project);
-            let selected_for_runtime = resolved_keys.contains(&skill.key);
-
-            ModeSkillInfo {
-                skill,
-                disabled_by_mode,
-                selected_for_runtime,
-            }
-        })
-        .collect())
+        // Mode-scoped built-in and user-level skills should still be available even
+        // when no project workspace is open. In that case there are simply no
+        // project-level overrides to apply.
+        Ok(registry.get_mode_skill_infos_for_workspace(None, mode_id).await)
+    }
 }
 
 fn normalize_skill_key_list(keys: Vec<String>) -> Vec<String> {
@@ -306,7 +244,7 @@ async fn persist_user_mode_skill_selection(
         .filter(|skill| skill.level == SkillLocation::User)
     {
         let should_enable = enabled_keys.contains(&skill.key);
-        let default_enabled = is_enabled_by_default_for_mode(skill, mode_id);
+        let default_enabled = resolve_skill_default_enabled_for_mode(skill, mode_id);
 
         if default_enabled && !should_enable {
             disabled_user_skills.push(skill.key.clone());
@@ -492,7 +430,7 @@ pub async fn set_mode_skill_disabled(
         }
         .ok_or_else(|| format!("Skill '{}' not found", skill_key))?;
 
-        let default_enabled = is_enabled_by_default_for_mode(&skill_info, &mode_id);
+        let default_enabled = resolve_skill_default_enabled_for_mode(&skill_info, &mode_id);
         set_user_mode_skill_state(&mode_id, &skill_key, !disabled, default_enabled)
             .await
             .map_err(|e| format!("Failed to update user skill override: {}", e))?;

src/crates/core/Cargo.toml

@@ -51,6 +51,7 @@ notify = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 filetime = { workspace = true }
+fs2 = { workspace = true }
 zip = { workspace = true }
 flate2 = { workspace = true }
 include_dir = { workspace = true }
@@ -143,3 +144,6 @@ schannel = "0.1"
 default = ["ssh-remote"]
 tauri-support = ["tauri"]  # Optional tauri support
 ssh-remote = ["russh", "russh-sftp", "russh-keys", "shellexpand", "ssh_config"]  # russh-keys pure-Rust crypto backend (no openssl)
+
+[build-dependencies]
+sha2 = { workspace = true }

src/crates/core/build.rs

@@ -1,6 +1,10 @@
 fn main() {
     emit_rerun_if_changed(std::path::Path::new("builtin_skills"));
 
+    if let Err(e) = build_embedded_builtin_skills_metadata() {
+        eprintln!("Warning: Failed to embed built-in skills metadata: {}", e);
+    }
+
     // Run the build script to embed prompts data
     if let Err(e) = build_embedded_prompts() {
         eprintln!("Warning: Failed to embed prompts data: {}", e);
@@ -12,6 +16,66 @@ fn main() {
     }
 }
 
+fn build_embedded_builtin_skills_metadata() -> Result<(), Box<dyn std::error::Error>> {
+    use sha2::{Digest, Sha256};
+    use std::fs;
+    use std::io::Write;
+    use std::path::{Path, PathBuf};
+
+    fn collect_files(root: &Path, current: &Path, out: &mut Vec<PathBuf>) -> std::io::Result<()> {
+        for entry in fs::read_dir(current)? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_dir() {
+                collect_files(root, &path, out)?;
+            } else if path.is_file() {
+                out.push(path.strip_prefix(root).unwrap_or(&path).to_path_buf());
+            }
+        }
+
+        Ok(())
+    }
+
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR")?;
+    let builtin_root = Path::new(&manifest_dir).join("builtin_skills");
+
+    println!("cargo:rerun-if-changed={}", builtin_root.display());
+    emit_rerun_if_changed(&builtin_root);
+
+    let mut files = Vec::new();
+    if builtin_root.exists() {
+        collect_files(&builtin_root, &builtin_root, &mut files)?;
+    }
+    files.sort();
+
+    let mut hasher = Sha256::new();
+    for relative_path in files {
+        let normalized = relative_path.to_string_lossy().replace('\\', "/");
+        hasher.update(normalized.as_bytes());
+        hasher.update([0]);
+        hasher.update(fs::read(builtin_root.join(&relative_path))?);
+        hasher.update([0xff]);
+    }
+    let bundle_hash = format!("{:x}", hasher.finalize());
+
+    let out_dir = std::env::var("OUT_DIR")?;
+    let dest_path = Path::new(&out_dir).join("embedded_builtin_skills.rs");
+    let mut file = fs::File::create(&dest_path)?;
+
+    writeln!(
+        file,
+        "// Embedded built-in skills metadata (auto-generated by build.rs)"
+    )?;
+    writeln!(file, "// Do not edit manually.")?;
+    writeln!(
+        file,
+        "pub const BUILTIN_SKILLS_BUNDLE_HASH: &str = \"{}\";",
+        bundle_hash
+    )?;
+
+    Ok(())
+}
+
 fn build_embedded_prompts() -> Result<(), Box<dyn std::error::Error>> {
     // Embed prompts data
     embed_agents_prompt_data()