@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-core/src/agent/skills.rs

@@ -5,7 +5,7 @@ use thiserror::Error;
 use crate::{LearnedSkill, MemoryError, MemoryStore};
 
 const MAX_SKILL_BYTES: u64 = 256 * 1024;
-const MAX_CONTEXT_BYTES: usize = 16 * 1024;
+const MAX_CONTEXT_BYTES: usize = 64 * 1024;
 
 #[derive(Debug, Error)]
 pub enum SkillError {
@@ -80,114 +80,206 @@ pub fn learned_skills_context(
     workspace_root: Option<&Path>,
     chat_id: Option<&str>,
 ) -> Result<String, SkillError> {
-    let mut skills = MemoryStore::open_default()?.learned_skills(20)?;
+    learned_skills_context_with_history(workspace_root, chat_id, "")
+}
 
-    if let Some(home) = dirs::home_dir() {
-        let global_agents_path = home.join(".gemini").join("config").join("AGENTS.md");
-        load_agent_rules_file(&global_agents_path, &mut skills);
+pub fn learned_skills_context_with_history(
+    workspace_root: Option<&Path>,
+    chat_id: Option<&str>,
+    history: &str,
+) -> Result<String, SkillError> {
+    let memory = MemoryStore::open_default()?;
+    let skills = crate::skill_inventory::skills_for_context(&memory, workspace_root)?;
+    skills_context_from_with_history(&memory, skills, workspace_root, chat_id, history)
+}
+
+#[cfg(test)]
+fn skills_context_from(
+    memory: &MemoryStore,
+    skills: Vec<LearnedSkill>,
+    _workspace_root: Option<&Path>,
+    chat_id: Option<&str>,
+) -> Result<String, SkillError> {
+    skills_context_from_with_history(memory, skills, _workspace_root, chat_id, "")
+}
 
-        let global_skills_path = home.join(".config").join("mint").join("mint-skills");
-        if !global_skills_path.exists() {
-            let _ = std::fs::create_dir_all(&global_skills_path);
+fn skills_context_from_with_history(
+    memory: &MemoryStore,
+    skills: Vec<LearnedSkill>,
+    _workspace_root: Option<&Path>,
+    chat_id: Option<&str>,
+    history: &str,
+) -> Result<String, SkillError> {
+    let mut unique_skills = std::collections::BTreeMap::new();
+    for mut skill in skills {
+        let path = Path::new(&skill.source_path);
+        if let Ok(canonical) = path.canonicalize() {
+            skill.source_path = canonical.to_string_lossy().into_owned();
         }
-        load_skills_from_dir(&global_skills_path, &mut skills);
+        unique_skills.insert(skill.source_path.clone(), skill);
     }
-
-    if let Some(root) = workspace_root {
-        let rule_files = [
-            root.join(".agents").join("AGENTS.md"),
-            root.join("AGENTS.md"),
-            root.join(".claude").join("CLAUDE.md"),
-            root.join("CLAUDE.md"),
-            root.join(".cursorrules"),
-            root.join(".github").join("copilot-instructions.md"),
-        ];
-        for rule_path in &rule_files {
-            if rule_path.is_file() {
-                load_agent_rules_file(rule_path, &mut skills);
+    let mut catalog = String::from(
+        "Choose only skills relevant to the task by their name and description. Before using an UNREAD skill, execute read_file on its Path without line limits. Do not read unrelated skills. READ means the exact unchanged content is retained in this request.\n\n",
+    );
+    let mut retained = String::new();
+    for skill in unique_skills.into_values() {
+        // Rules apply to every task; they are not optional skills.
+        if is_rules_file(Path::new(&skill.source_path)) {
+            if let Ok(content) = fs::read_to_string(&skill.source_path) {
+                retained.push_str(&format!(
+                    "Workspace instructions: {}\n{}\n\n",
+                    skill.source_path, content
+                ));
             }
+            continue;
         }
-
-        let cursor_rules_dir = root.join(".cursor").join("rules");
-        if let Ok(entries) = std::fs::read_dir(cursor_rules_dir) {
-            for entry in entries.flatten() {
-                let path = entry.path();
-                if path.is_file()
-                    && (path.extension().and_then(|e| e.to_str()) == Some("mdc")
-                        || path.extension().and_then(|e| e.to_str()) == Some("md"))
-                {
-                    load_agent_rules_file(&path, &mut skills);
-                }
-            }
+        let current = fs::read_to_string(&skill.source_path).ok();
+        let saved = match chat_id {
+            Some(id) => memory.skill_read_content(id, &skill.source_path)?,
+            None => None,
+        };
+        let available = current
+            .as_ref()
+            .filter(|content| saved.as_ref() == Some(*content));
+        let body = available.map(|content| {
+            format!(
+                "Loaded skill: {}\nPath: {}\n{}\n\n",
+                skill.name, skill.source_path, content
+            )
+        });
+        // Never mark a skill READ if its full contents won't be sent to the model.
+        let visible = available.is_some_and(|content| {
+            history.contains(&format!("[Loaded skill: {}]\n{}", skill.name, content))
+        });
+        let replayable = body
+            .as_ref()
+            .is_some_and(|body| retained.len() + body.len() <= MAX_CONTEXT_BYTES);
+        let loaded = visible || replayable;
+        if replayable && !visible {
+            retained.push_str(body.as_ref().unwrap());
         }
+        let description = current
+            .as_deref()
+            .and_then(parse_skill_description)
+            .or(skill.description)
+            .unwrap_or_else(|| "No description provided".into());
+        catalog.push_str(&format!(
+            "Skill: {}\nDescription: {}\nPath: {}\nStatus: {}\n\n",
+            skill.name,
+            description,
+            skill.source_path,
+            if loaded {
+                "READ — full unchanged content retained in this request."
+            } else {
+                "UNREAD — read this file through read_file before using it."
+            }
+        ));
+    }
+    Ok(format!("{catalog}\n{retained}"))
+}
 
-        let workspace_skills_path1 = root.join(".agents").join("skills");
-        load_skills_from_dir(&workspace_skills_path1, &mut skills);
+pub(super) fn is_rules_file(path: &Path) -> bool {
+    matches!(
+        path.file_name().and_then(|name| name.to_str()),
+        Some("AGENTS.md" | "CLAUDE.md" | ".cursorrules" | "copilot-instructions.md")
+    ) || path
+        .parent()
+        .is_some_and(|parent| parent.ends_with(".cursor/rules"))
+}
 
-        let workspace_skills_path2 = root.join("skills");
-        load_skills_from_dir(&workspace_skills_path2, &mut skills);
+/// Skill sources and their installed resources change persistent instructions.
+/// Include taught source files even when they use an ordinary filename or have
+/// been deleted and are about to be recreated. Lookup failures fail closed.
+pub(crate) fn skill_edit_requires_approval(root: &Path, path: &Path) -> Result<bool, SkillError> {
+    if is_skill_tree_path(root, path) {
+        return Ok(true);
     }
+    skill_edit_requires_approval_with_memory(&MemoryStore::open_default()?, root, path)
+}
 
-    let mut unique_skills = std::collections::BTreeMap::new();
-    for skill in skills {
-        unique_skills.insert(skill.name.clone(), skill);
+fn is_skill_tree_path(root: &Path, path: &Path) -> bool {
+    if path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| matches!(name.to_ascii_lowercase().as_str(), "skill.md" | "skill.txt"))
+    {
+        return true;
     }
-
-    let mut has_history = false;
-    if let Some(cid) = chat_id {
-        if let Ok(memory) = MemoryStore::open_default() {
-            if let Ok(interactions) = memory.recent_completed_interactions_for_chat(cid, 1) {
-                has_history = !interactions.is_empty();
-            }
-        }
+    let mut directories = vec![root.join(".agents/skills"), root.join("skills")];
+    if let Some(home) = dirs::home_dir() {
+        directories.push(home.join(".config/mint/mint-skills"));
     }
+    directories.into_iter().any(|directory| {
+        path.starts_with(&directory)
+            || directory
+                .canonicalize()
+                .is_ok_and(|canonical| path.starts_with(canonical))
+    })
+}
 
-    let mut formatted_skills = Vec::new();
-    for skill in unique_skills.into_values() {
-        let mut is_workspace_skill = false;
-        let mut rel_path = String::new();
-        if let Some(root) = workspace_root {
-            let skill_path = Path::new(&skill.source_path);
-            if let Ok(canonical_skill) = skill_path.canonicalize() {
-                if let Ok(canonical_root) = root.canonicalize() {
-                    if canonical_skill.starts_with(&canonical_root) {
-                        if let Ok(relative) = canonical_skill.strip_prefix(&canonical_root) {
-                            is_workspace_skill = true;
-                            rel_path = relative.to_string_lossy().to_string();
-                        }
-                    }
-                }
-            }
-        }
+fn skill_edit_requires_approval_with_memory(
+    memory: &MemoryStore,
+    root: &Path,
+    path: &Path,
+) -> Result<bool, SkillError> {
+    if is_skill_tree_path(root, path) {
+        return Ok(true);
+    }
+    let target = path.canonicalize().unwrap_or_else(|_| path.to_owned());
+    // Match the complete registry, including sources outside the workspace.
+    Ok(memory
+        .learned_skill_sources()?
+        .into_iter()
+        .any(|source_path| {
+            let source = Path::new(&source_path);
+            source.canonicalize().unwrap_or_else(|_| source.to_owned()) == target
+        }))
+}
 
-        if is_workspace_skill {
-            let desc = skill
-                .description
-                .as_deref()
-                .unwrap_or("No description provided");
-            let status_msg = if has_history {
-                "READ. You have already read this skill in a previous turn of this conversation. Do NOT call `read_file` to read it again unless you need to re-verify its contents."
-            } else {
-                "UNREAD. You MUST execute the `read_file` tool with the path above to read this skill before starting the task."
-            };
-            formatted_skills.push(format!(
-                "Skill: {}\nDescription: {}\nPath: {}\nStatus: {}",
-                skill.name, desc, rel_path, status_msg
-            ));
-        } else {
-            formatted_skills.push(format!("Skill: {}\n{}", skill.name, skill.content));
-        }
+/// Resolve only a file the skill catalog actually advertises, including taught/global skills.
+pub fn skill_for_read_path(root: &Path, path: &str) -> Option<LearnedSkill> {
+    let canonical = root.join(path).canonicalize().ok()?;
+    if is_rules_file(&canonical) {
+        return None;
     }
+    let memory = MemoryStore::open_default().ok()?;
+    crate::skill_inventory::list_available_skills(&memory, Some(root))
+        .ok()?
+        .into_iter()
+        .map(|entry| entry.skill)
+        .find(|skill| {
+            Path::new(&skill.source_path).canonicalize().ok().as_ref() == Some(&canonical)
+        })
+        .map(|mut skill| {
+            skill.source_path = canonical.to_string_lossy().into_owned();
+            skill
+        })
+}
 
-    let value = formatted_skills.join("\n\n");
-    if value.len() <= MAX_CONTEXT_BYTES {
-        return Ok(value);
+/// Full skill reads intentionally don't use the normal 240-line source preview.
+/// The receipt is saved only after a real, capability-checked read succeeds.
+pub fn read_skill_file(
+    memory: &MemoryStore,
+    skill: &LearnedSkill,
+    chat_id: &str,
+    config: &crate::MintConfig,
+) -> Result<String, SkillError> {
+    let path = crate::assert_path_capability(
+        Path::new(&skill.source_path),
+        crate::Capability::Read,
+        config,
+    )
+    .map_err(|error| std::io::Error::other(error.to_string()))?;
+    let metadata = fs::metadata(&path)?;
+    if metadata.len() > MAX_SKILL_BYTES {
+        return Err(SkillError::TooLarge(metadata.len()));
     }
-    let mut end = MAX_CONTEXT_BYTES;
-    while !value.is_char_boundary(end) {
-        end -= 1;
+    let content = fs::read_to_string(&path)?;
+    if content.len() as u64 > MAX_SKILL_BYTES {
+        return Err(SkillError::TooLarge(content.len() as u64));
     }
-    Ok(format!("{}\n...<learned skills truncated>", &value[..end]))
+    memory.record_skill_read(chat_id, &path.to_string_lossy(), &content)?;
+    Ok(format!("[Loaded skill: {}]\n{}", skill.name, content))
 }
 
 pub fn parse_skill_description(content: &str) -> Option<String> {
@@ -275,6 +367,234 @@ pub fn load_skills_from_dir(dir: &Path, list: &mut Vec<LearnedSkill>) {
 mod tests {
     use super::*;
 
+    fn fixture() -> (std::path::PathBuf, MemoryStore, Vec<LearnedSkill>) {
+        let root = std::env::temp_dir().join(format!(
+            "mint-skill-context-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        let directory = root.join(".agents/skills/review");
+        fs::create_dir_all(&directory).unwrap();
+        fs::write(
+            directory.join("SKILL.md"),
+            "---\ndescription: Review code\n---\nReview every changed function.",
+        )
+        .unwrap();
+        let mut skills = Vec::new();
+        load_skills_from_dir(&root.join(".agents/skills"), &mut skills);
+        let memory = MemoryStore::open(root.join("memory.sqlite"));
+        (root, memory, skills)
+    }
+
+    #[test]
+    fn protects_skill_resources_and_flat_skills_but_not_ordinary_source_files() {
+        let (root, memory, _) = fixture();
+        for path in [
+            ".agents/skills/build/scripts/build.sh",
+            "skills/deploy.md",
+            "skills/example/skill.txt",
+            ".codex/skills/example/SKILL.md",
+        ] {
+            assert!(
+                skill_edit_requires_approval_with_memory(&memory, &root, &root.join(path)).unwrap(),
+                "{path}"
+            );
+        }
+        assert!(
+            !skill_edit_requires_approval_with_memory(&memory, &root, &root.join("src/skills.rs"))
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn edits_to_taught_skill_sources_require_approval_outside_skill_directories() {
+        let (root, memory, _) = fixture();
+        let path = root.join("playbook.md");
+        fs::write(&path, "Reusable instructions").unwrap();
+        memory
+            .add_learned_skill("playbook", &path.to_string_lossy(), "Reusable instructions")
+            .unwrap();
+        assert!(skill_edit_requires_approval_with_memory(&memory, &root, &path).unwrap());
+        fs::remove_file(&path).unwrap();
+        // A registered source remains protected when recreated.
+        assert!(skill_edit_requires_approval_with_memory(&memory, &root, &path).unwrap());
+        assert!(
+            !skill_edit_requires_approval_with_memory(&memory, &root, &root.join("app.rs"))
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn conversation_history_does_not_mark_unread_skills_as_loaded() {
+        let (root, memory, skills) = fixture();
+        memory
+            .add_interaction_for_chat("session-a", "hello", "hello", "", "")
+            .unwrap();
+        let context = skills_context_from(&memory, skills, Some(&root), Some("session-a")).unwrap();
+        assert!(context.contains("Status: UNREAD"), "{context}");
+        assert!(!context.contains("Review every changed function."));
+    }
+
+    #[test]
+    fn global_skills_are_catalog_entries_not_preloaded_bodies() {
+        let (root, memory, skills) = fixture();
+        let context = skills_context_from(&memory, skills, None, Some("session-a")).unwrap();
+        assert!(context.contains("Description: Review code"), "{context}");
+        assert!(context.contains("Path:"));
+        assert!(!context.contains("Review every changed function."));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn successful_reads_are_scoped_to_session_and_changed_files_need_new_reads() {
+        let (root, memory, skills) = fixture();
+        let skill = &skills[0];
+        memory
+            .record_skill_read("session-a", &skill.source_path, &skill.content)
+            .unwrap();
+        let loaded =
+            skills_context_from(&memory, skills.clone(), Some(&root), Some("session-a")).unwrap();
+        assert!(loaded.contains("Status: READ"), "{loaded}");
+        assert!(loaded.contains("Review every changed function."));
+        let other =
+            skills_context_from(&memory, skills.clone(), Some(&root), Some("session-b")).unwrap();
+        assert!(other.contains("Status: UNREAD"));
+        assert!(!other.contains("Review every changed function."));
+        fs::write(
+            &skill.source_path,
+            "---\ndescription: Review code\n---\nNew instructions.",
+        )
+        .unwrap();
+        let changed =
+            skills_context_from(&memory, skills.clone(), Some(&root), Some("session-a")).unwrap();
+        assert!(changed.contains("Status: UNREAD"), "{changed}");
+        assert!(!changed.contains("Review every changed function."));
+        memory.clear_interactions_for_chat("session-a").unwrap();
+        assert!(
+            memory
+                .skill_read_content("session-a", &skill.source_path)
+                .unwrap()
+                .is_none()
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn full_read_returns_all_lines_and_records_only_successful_reads() {
+        let (root, memory, mut skills) = fixture();
+        let content = (1..=300)
+            .map(|i| format!("Instruction {i}\n"))
+            .collect::<String>();
+        fs::write(&skills[0].source_path, &content).unwrap();
+        let config = crate::MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            blocked_paths: vec![],
+            ..Default::default()
+        };
+        let result = read_skill_file(&memory, &skills[0], "session-a", &config).unwrap();
+        assert!(result.contains("Instruction 300\n"));
+        assert_eq!(
+            memory
+                .skill_read_content("session-a", &skills[0].source_path)
+                .unwrap(),
+            Some(content)
+        );
+        let denied = crate::MintConfig {
+            allowed_read_paths: vec![],
+            blocked_paths: vec![root.clone()],
+            ..config.clone()
+        };
+        assert!(read_skill_file(&memory, &skills[0], "denied", &denied).is_err());
+        assert!(
+            memory
+                .skill_read_content("denied", &skills[0].source_path)
+                .unwrap()
+                .is_none()
+        );
+        // Missing paths do not become receipts either.
+        skills[0].source_path = root.join("missing.md").to_string_lossy().into_owned();
+        assert!(read_skill_file(&memory, &skills[0], "missing", &config).is_err());
+        assert!(
+            memory
+                .skill_read_content("missing", &skills[0].source_path)
+                .unwrap()
+                .is_none()
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn receipts_not_included_in_context_are_not_marked_read() {
+        let (root, memory, skills) = fixture();
+        let large = "x".repeat(MAX_CONTEXT_BYTES + 1);
+        fs::write(&skills[0].source_path, &large).unwrap();
+        memory
+            .record_skill_read("a", &skills[0].source_path, &large)
+            .unwrap();
+        let context = skills_context_from(&memory, skills, Some(&root), Some("a")).unwrap();
+        assert!(context.contains("Status: UNREAD"));
+        assert!(!context.contains(&large));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn project_rules_are_present_without_being_optional_skills() {
+        let (root, memory, mut skills) = fixture();
+        fs::write(root.join("AGENTS.md"), "Always preserve user changes.").unwrap();
+        load_agent_rules_file(&root.join("AGENTS.md"), &mut skills);
+        let context = skills_context_from(&memory, skills, Some(&root), Some("a")).unwrap();
+        assert!(context.contains("Always preserve user changes."));
+        assert!(!context.contains("Skill: AGENTS.md"));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn reading_one_skill_does_not_mark_another_read_and_receipts_survive_reopen() {
+        let (root, memory, mut skills) = fixture();
+        let other = root.join("skills/build/SKILL.md");
+        fs::create_dir_all(other.parent().unwrap()).unwrap();
+        fs::write(
+            &other,
+            "---\ndescription: Build projects\n---\nRun the build.",
+        )
+        .unwrap();
+        load_skills_from_dir(&root.join("skills"), &mut skills);
+        let config = crate::MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            blocked_paths: vec![],
+            ..Default::default()
+        };
+        read_skill_file(&memory, &skills[0], "a", &config).unwrap();
+        let reopened = MemoryStore::open(root.join("memory.sqlite"));
+        let context = skills_context_from(&reopened, skills, Some(&root), Some("a")).unwrap();
+        assert!(context.contains("Review every changed function."));
+        assert!(!context.contains("Run the build."));
+        let build = context.split("Skill: build\n").nth(1).unwrap();
+        assert!(
+            build
+                .split("\n\n")
+                .next()
+                .unwrap()
+                .contains("Status: UNREAD")
+        );
+        memory.delete_chat_session("a").unwrap();
+        assert!(
+            reopened
+                .skill_read_content(
+                    "a",
+                    &root
+                        .join(".agents/skills/review/SKILL.md")
+                        .to_string_lossy()
+                )
+                .unwrap()
+                .is_none()
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn test_fs_skills_loading() {
         let test_dir = std::env::temp_dir().join("mint_skills_test_unique_dir");
@@ -304,4 +624,32 @@ mod tests {
         let js_skill = list.iter().find(|s| s.name == "js-style").unwrap();
         assert_eq!(js_skill.content, "Use 2 spaces for JS.");
     }
+    #[test]
+    fn large_skill_already_visible_in_request_is_read_without_cached_replay() {
+        let (root, memory, skills) = fixture();
+        let content = "instruction\n".repeat(8000);
+        fs::write(&skills[0].source_path, &content).unwrap();
+        memory
+            .record_skill_read("a", &skills[0].source_path, &content)
+            .unwrap();
+        let history = format!("[Loaded skill: {}]\n{}", skills[0].name, content);
+        let context = skills_context_from_with_history(
+            &memory,
+            skills.clone(),
+            Some(&root),
+            Some("a"),
+            &history,
+        )
+        .unwrap();
+        assert!(context.contains("Status: READ"));
+        let lost = skills_context_from_with_history(
+            &memory,
+            skills,
+            Some(&root),
+            Some("a"),
+            "summary only",
+        )
+        .unwrap();
+        assert!(lost.contains("Status: UNREAD"));
+    }
 }

package/crates/mint-core/src/agent.rs

@@ -7,6 +7,7 @@ pub mod chat;
 pub mod code_tools;
 pub mod memory;
 pub mod safety;
+pub mod skill_inventory;
 pub mod skills;
 pub mod subagents;
 pub mod tasks;

package/crates/mint-core/src/api_server/routes/auth.rs

@@ -128,10 +128,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
                 "gif" => "image/gif",
                 _ => "image/png",
             };
-            let file_path = profile_pictures_dir()
-                .ok()
-                .filter(|_| !filename.is_empty())
-                .map(|dir| dir.join(&filename));
+            let file_path = resolve_avatar_file_path(&filename);
             match file_path.and_then(|path| std::fs::read(path).ok()) {
                 Some(bytes) => send_binary_response(socket, "200 OK", content_type, &bytes).await,
                 None => {