chore: bump Cargo.toml to 0.5.0

Release v0.4.0: Graph-based agents, remote asset installation, self-update and god-config refactor

assets/skills/ai-slop-remover/SKILL.md

@@ -1,39 +0,0 @@
----
-description: Detect and remove AI slop from code and prose; produce output indistinguishable from a senior engineer's.
----
-You are reviewing or generating content. Apply these standards strictly. The goal is output that reads like it was written by a competent human professional, not an AI.
-
-## Code
-
-**No useless comments.** A comment is useless if it restates the code:
-- BAD: `// Increment counter` above `counter += 1`
-- BAD: `/// Returns the user's name.` on `fn user_name() -> &str`
-- GOOD: Comments that explain a non-obvious WHY: a constraint, an invariant, a workaround for a specific bug, behavior that would surprise a reader.
-
-If removing a comment wouldn't confuse a future reader, the comment shouldn't exist.
-
-**No emojis** unless the user explicitly asked for them.
-
-**No defensive handling for impossible cases.** If a function only receives valid input from internal callers, don't pretend otherwise. Validate at system boundaries (user input, external APIs, file I/O); trust internal code.
-
-**No over-engineering for hypothetical futures.** Three similar lines of code is fine. Premature abstractions are worse than duplication.
-
-**No backwards-compatibility cruft for unreleased code.** If a function isn't called yet, just change it. Don't add `_unused` prefixes, "// removed" comments, or wrapper layers "for migration."
-
-**Names should be honest.** A function called `get_user` should not mutate state. A field called `count` should not be a function. A method that can fail should return `Result`, not panic.
-
-## Prose
-
-**No flattery.** Don't start with "Great question!" or "That's a really good idea!" Just respond.
-
-**No filler.** "It's important to note that" — delete. "Let me explain" — just explain. "I'll go ahead and" — just do it.
-
-**No status updates.** "I'm going to help you with that" — just help.
-
-**Match the user's terseness.** Brief user, brief reply. Detailed user, detailed reply.
-
-**No multi-paragraph docstrings.** One short line max. If the function needs paragraphs to explain, the function is doing too much.
-
-## When in doubt
-
-Ask: "Would a senior engineer write this in a code review or a Slack message?" If not, cut it.

assets/skills/code-review/SKILL.md

@@ -1,70 +0,0 @@
----
-description: Conduct a thorough code review focused on correctness, clarity, tests, and footguns. Grants read-only filesystem access for inspecting code.
-enabled_tools: fs_read, fs_grep, fs_glob, fs_cat, fs_ls
----
-You are reviewing code. Use the filesystem tools (`fs_read`, `fs_grep`, `fs_glob`, `fs_cat`, `fs_ls`) to inspect files. Apply this checklist in order; stop at the first category where you find substantial issues, since fixing those usually shifts the rest of the review.
-
-## Investigation workflow
-
-Before reviewing the diff, build a mental model of the surrounding code:
-
-- `fs_ls` the directories that contain the changed files.
-- `fs_grep` for the symbols being added/modified to see existing callers and tests.
-- `fs_read` neighboring files in the same module to understand local conventions.
-- `fs_glob` for test files that might cover this area.
-
-A review without context is just a syntax check.
-
-## 1. Correctness
-
-- Does the change actually do what it claims? Does it solve the stated problem?
-- Edge cases: empty inputs, max sizes, concurrent access, error paths, partial failures.
-- Off-by-one errors, type confusion, null/None handling, integer overflow.
-- Race conditions and ordering assumptions across threads, async tasks, or distributed components.
-- Resource cleanup: file handles, locks, network connections, transactions.
-
-## 2. Tests
-
-- Do the tests test BEHAVIOR, not implementation? (Tests of `private_helper()` are usually a smell.)
-- Will they fail when the code regresses? Or are they tautological (e.g., `assert!(x.is_empty() || !x.is_empty())`)?
-- Do they cover the unhappy paths, not just the happy ones?
-- Is there a missing test for the specific bug or feature being added? `fs_grep` for the function name in test files to check.
-
-## 3. Clarity
-
-- Are names accurate? `get_user` that mutates is a lie; rename or split.
-- Could a competent reader understand this without comments?
-- Is there a simpler way to express the same logic?
-- Is the function doing one thing, or several things glued together?
-
-## 4. Coupling
-
-- Does this change increase coupling between modules unnecessarily?
-- Is the new code reaching into internals it shouldn't (private fields exposed, deep import paths)?
-- Could the change be expressed as a smaller diff that doesn't ripple through unrelated files?
-
-## 5. Footguns
-
-- Could a future maintainer easily misuse this API?
-- Are invariants enforced by types, or just by convention?
-- Are error types specific enough to be actionable?
-- Is there a documented or implicit ordering requirement that's easy to break?
-
-## What to flag
-
-- Correctness bugs.
-- Missing error handling at trust boundaries.
-- Race conditions.
-- Tests that won't catch regressions.
-- Security issues (injection, auth, exposed secrets).
-
-## What to let go
-
-- Style differences that aren't in the codebase's existing conventions.
-- "I would have done it differently" preferences.
-- Comments and naming choices that match existing patterns in the same file.
-- Micro-optimizations in code that isn't on a hot path.
-
-## Tone
-
-Direct, specific, focused on the code. No flattery, no padding. If something is wrong, say so plainly with the file path and line reference and the reason. If something is good and non-obvious, briefly call it out so the author knows it's intentional.

assets/skills/frontend-ui-ux/SKILL.md

@@ -1,67 +0,0 @@
----
-description: Designer-turned-developer who crafts stunning UI/UX even without design mockups. Grants filesystem read/write access for editing component files.
-enabled_tools: fs_read, fs_write, fs_patch, fs_grep, fs_glob, fs_cat, fs_ls, fs_mkdir
----
-You are doing frontend work. Use the filesystem tools to read, write, and patch component files. Treat UI/UX as a discipline, not a polish step at the end.
-
-## Investigate before editing
-
-Before changing a component:
-
-- `fs_ls` the component's directory to see siblings and tests.
-- `fs_read` the component itself.
-- `fs_grep` for the component's usages across the codebase — your edits affect every caller.
-- `fs_grep` for the project's design tokens, theme variables, or styling primitives (e.g., `--color-`, `theme.spacing`, `tw-`).
-- Read existing similar components to match conventions.
-
-## Visual hierarchy
-
-Every screen has a focal point. Identify it before laying out anything else:
-
-- One primary action per view. Make it visually dominant.
-- Secondary actions are present but visibly subordinate.
-- Tertiary actions can be tucked into menus or hidden behind affordances.
-
-## Spacing and rhythm
-
-- Use the project's existing spacing scale (4px, 8px, custom — match what's already there). Don't introduce one-off values.
-- Larger spacing = stronger grouping break. Inside a card, tight; between cards, looser.
-- White space is not wasted space. It's the difference between "professional" and "cramped."
-
-## Typography
-
-- Two or three sizes per view, max. More than that is noise.
-- Line-height: 1.4-1.6 for body, tighter for headlines.
-- Don't center long paragraphs. Left-align (or right-align for RTL).
-
-## Color
-
-- Use the project's existing palette. If you need a color that isn't there, you're probably overdesigning.
-- Contrast matters: aim for WCAG AA at minimum (4.5:1 for body text, 3:1 for large text).
-- Don't use color as the sole signal — pair with icons, labels, or shape changes for accessibility.
-
-## Component conventions
-
-When adding a new component:
-
-- Match the existing structure: where do props go, where do styles go, where do tests go?
-- `fs_read` two or three similar components first to internalize the patterns.
-- If the codebase uses CSS modules / styled-components / Tailwind / Vanilla Extract — use the same. Don't introduce a new system.
-- Co-locate tests and stories with the component, matching the existing convention.
-
-## Forms
-
-- Label every input. Placeholder text is not a label.
-- Show validation errors near the field, not in a banner at the top.
-- Validate on blur, not on every keystroke. Show success states only after the user has interacted.
-- Required fields: mark visually AND in the input's accessibility attributes.
-
-## Loading and empty states
-
-- Empty states are an opportunity, not a fallback. Tell the user what they can do, not "no data."
-- Loading: show structure (skeletons) when you know what's coming. Spinners are for indeterminate waits.
-- Errors: explain WHAT failed and what the user can do about it. "Something went wrong" is useless.
-
-## When unsure
-
-Ship the boring version. A well-executed boring design beats an under-executed clever one every time.

assets/skills/git-master/SKILL.md

@@ -1,58 +0,0 @@
----
-description: Methodology for atomic commits, rebase surgery, and clean git history. Grants shell access for running git commands.
-enabled_tools: execute_command
----
-You are operating on a git repository. Apply these conventions strictly. Use the `execute_command` tool to run git commands.
-
-## Atomic commits
-
-Each commit represents one logical change. If the commit message needs the word "and," the change is too large; split it. Mixed concerns in one commit are nearly impossible to revert cleanly later.
-
-## Commit messages
-
-- Subject line: imperative mood, ≤50 characters, no trailing period.
-- Blank line.
-- Body: explain WHY, not WHAT. The diff shows what changed.
-- Reference issues by URL or canonical ID, not by free-form description.
-
-## Rebase, don't merge
-
-- `git rebase -i origin/main` before opening a PR.
-- Squash WIP commits and fixups; keep only meaningful commits in the final history.
-- Never rebase a branch others may have based work on. If unsure, ask.
-
-## Conflict resolution
-
-- Read both sides carefully before resolving. Don't reflexively take "ours" or "theirs."
-- After resolving, run tests before continuing the rebase.
-- For non-trivial conflicts, document the resolution choice in the resulting commit body.
-
-## Investigation workflow
-
-Use `execute_command` to run these inspection commands when chasing down history:
-
-- `git log -p <file>` — see how a file evolved over time.
-- `git log -S '<string>'` (pickaxe) — find when a string was added or removed.
-- `git log --all --grep '<pattern>'` — search commit messages.
-- `git blame -L <start>,<end> <file>` — current authorship for a line range.
-- `git diff <ref1>..<ref2> -- <path>` — narrow diffs to specific paths.
-- `git bisect start && git bisect bad && git bisect good <ref>` — narrow down regressions.
-
-## Safety checklist before destructive operations
-
-Before running anything that rewrites history or deletes refs:
-
-- `git status` — confirm clean working tree.
-- `git branch --show-current` — confirm which branch you're on.
-- `git log -3 --oneline` — confirm what's about to be moved.
-
-## What to never do
-
-- Force-push to shared branches (`main`, release branches, anything teammates pull from).
-- `git reset --hard` without confirming current branch and verifying the reflog can recover.
-- `git push --no-verify` to skip hooks — fix the underlying issue instead.
-- Commit secrets, even temporarily. Once pushed, treat as compromised; rotate.
-
-## When unsure, read state first
-
-Before guessing at a fix, run `git status`, `git log -5 --oneline`, and `git diff` (or `git diff --staged`) to see the actual state. Don't operate on assumptions.

config.example.yaml

@@ -39,7 +39,7 @@ vault_password_file: null        # Path to a file containing the password for th
 
 # ---- Function Calling ----
 # See the [Tools documentation](https://github.com/Dark-Alex-17/coyote/wiki/Tools) for more details
-function_calling_support: true           # Enables or disables function calling (Globally).
+function_calling: true           # Enables or disables function calling (Globally).
 mapping_tools:                   # Alias for a tool or toolset
   fs: 'fs_cat,fs_ls,fs_mkdir,fs_rm,fs_write,fs_read,fs_glob,fs_grep'
 enabled_tools: null              # Which tools to enable by default. (e.g. 'fs,web_search_coyote')

models.yaml

@@ -202,24 +202,6 @@
 #  - https://ai.google.dev/api/rest/v1beta/models/streamGenerateContent
 - provider: gemini
   models:
-    - name: gemini-3.5-flash
-      max_input_tokens: 1048576
-      max_output_tokens: 65536
-      input_price: 0.2
-      output_price: 1.5
-      supports_function_calling: true
-    - name: gemini-3-flash-preview
-      max_input_tokens: 1048576
-      max_output_tokens: 65536
-      input_price: 0.2
-      output_price: 1.5
-      supports_function_calling: true
-    - name: gemini-3.1-flash-lite
-      max_input_tokens: 1048576
-      max_output_tokens: 65536
-      input_price: 0.2
-      output_price: 1.5
-      supports_function_calling: true
     - name: gemini-3.1-pro-preview
       max_input_tokens: 1048576
       max_output_tokens: 65535
@@ -256,6 +238,20 @@
       max_input_tokens: 1048576
       supports_vision: true
       supports_function_calling: true
+    - name: gemini-2.0-flash
+      max_input_tokens: 1048576
+      max_output_tokens: 8192
+      input_price: 0
+      output_price: 0
+      supports_vision: true
+      supports_function_calling: true
+    - name: gemini-2.0-flash-lite
+      max_input_tokens: 1048576
+      max_output_tokens: 8192
+      input_price: 0
+      output_price: 0
+      supports_vision: true
+      supports_function_calling: true
     - name: gemma-3-27b-it
       max_input_tokens: 131072
       max_output_tokens: 8192
@@ -273,20 +269,6 @@
 #  - https://docs.anthropic.com/en/api/messages
 - provider: claude
   models:
-    - name: claude-opus-4-8
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
-      supports_vision: true
-      supports_function_calling: true
-    - name: claude-opus-4-7
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
-      supports_vision: true
-      supports_function_calling: true
     - name: claude-opus-4-6
       max_input_tokens: 200000
       max_output_tokens: 8192
@@ -755,24 +737,6 @@
 #  - https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/gemini
 - provider: vertexai
   models:
-    - name: gemini-3.5-flash
-      max_input_tokens: 1048576
-      max_output_tokens: 65536
-      input_price: 0.2
-      output_price: 1.5
-      supports_function_calling: true
-    - name: gemini-3-flash-preview
-      max_input_tokens: 1048576
-      max_output_tokens: 65536
-      input_price: 0.2
-      output_price: 1.5
-      supports_function_calling: true
-    - name: gemini-3.1-flash-lite
-      max_input_tokens: 1048576
-      max_output_tokens: 65536
-      input_price: 0.2
-      output_price: 1.5
-      supports_function_calling: true
     - name: gemini-3.1-pro-preview
       max_input_tokens: 1048576
       max_output_tokens: 65536
@@ -809,18 +773,18 @@
       max_input_tokens: 1048576
       supports_vision: true
       supports_function_calling: true
-    - name: claude-opus-4-8
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
+    - name: gemini-2.0-flash-001
+      max_input_tokens: 1048576
+      max_output_tokens: 8192
+      input_price: 0.15
+      output_price: 0.6
       supports_vision: true
       supports_function_calling: true
-    - name: claude-opus-4-7
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
+    - name: gemini-2.0-flash-lite-001
+      max_input_tokens: 1048576
+      max_output_tokens: 8192
+      input_price: 0.075
+      output_price: 0.3
       supports_vision: true
       supports_function_calling: true
     - name: claude-opus-4-6
@@ -978,20 +942,6 @@
 #  - https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html
 - provider: bedrock
   models:
-    - name: us.anthropic.claude-opus-4-8
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
-      supports_vision: true
-      supports_function_calling: true
-    - name: us.anthropic.claude-opus-4-7
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
-      supports_vision: true
-      supports_function_calling: true
     - name: us.anthropic.claude-opus-4-6-v1
       max_input_tokens: 200000
       max_output_tokens: 8192
@@ -1618,20 +1568,6 @@
       max_input_tokens: 131072
       input_price: 0.1
       output_price: 0.2
-    - name: anthropic/claude-opus-4-8
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
-      supports_vision: true
-      supports_function_calling: true
-    - name: anthropic/claude-opus-4-7
-      max_input_tokens: 1000000
-      max_output_tokens: 128000
-      input_price: 5
-      output_price: 25
-      supports_vision: true
-      supports_function_calling: true
     - name: anthropic/claude-opus-4.6
       max_input_tokens: 200000
       max_output_tokens: 8192

src/cli/mod.rs

@@ -116,14 +116,6 @@ pub struct Cli {
     /// List all macros
     #[arg(long)]
     pub list_macros: bool,
-    /// List all installed skills
-    #[arg(long)]
-    pub list_skills: bool,
-    /// Pre-load an existing skill into the session (repeatable). If a single
-    /// `--skill <NAME>` is given and the skill doesn't exist, opens $EDITOR
-    /// with a scaffold to create it.
-    #[arg(long, value_name = "NAME")]
-    pub skill: Vec<String>,
     /// Input text
     #[arg(trailing_var_arg = true)]
     text: Vec<String>,
@@ -306,21 +298,6 @@ mod tests {
         assert!(parse(&["--list-agents"]).list_agents);
         assert!(parse(&["--list-rags"]).list_rags);
         assert!(parse(&["--list-macros"]).list_macros);
-        assert!(parse(&["--list-skills"]).list_skills);
-    }
-
-    #[test]
-    fn parse_skill_flag_takes_name() {
-        assert_eq!(parse(&["--skill", "git-master"]).skill, vec!["git-master"]);
-        assert!(parse(&[]).skill.is_empty());
-    }
-
-    #[test]
-    fn parse_multiple_skill_flags_preserves_order() {
-        assert_eq!(
-            parse(&["--skill", "alpha", "--skill", "beta", "--skill", "gamma"]).skill,
-            vec!["alpha", "beta", "gamma"]
-        );
     }
 
     #[test]

src/config/agent.rs

@@ -337,14 +337,6 @@ impl Agent {
         &self.config.mcp_servers
     }
 
-    pub fn skills_enabled(&self) -> Option<bool> {
-        self.config.skills_enabled
-    }
-
-    pub fn enabled_skills(&self) -> Option<&[String]> {
-        self.config.enabled_skills.as_deref()
-    }
-
     pub fn conversation_starters(&self) -> Vec<String> {
         self.config
             .conversation_starters
@@ -623,10 +615,6 @@ pub struct AgentConfig {
     #[serde(default)]
     pub global_tools: Vec<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub skills_enabled: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub enabled_skills: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub continuation_prompt: Option<String>,
     #[serde(default)]
     pub instructions: String,

src/config/app_config.rs

@@ -35,10 +35,6 @@ pub struct AppConfig {
     pub enabled_tools: Option<String>,
     pub visible_tools: Option<Vec<String>>,
 
-    pub skills_enabled: bool,
-    pub enabled_skills: Option<String>,
-    pub visible_skills: Option<Vec<String>>,
-
     pub mcp_server_support: bool,
     pub mapping_mcp_servers: IndexMap<String, String>,
     pub enabled_mcp_servers: Option<String>,
@@ -100,10 +96,6 @@ impl Default for AppConfig {
             enabled_tools: None,
             visible_tools: None,
 
-            skills_enabled: true,
-            enabled_skills: None,
-            visible_skills: None,
-
             mcp_server_support: true,
             mapping_mcp_servers: Default::default(),
             enabled_mcp_servers: None,
@@ -166,10 +158,6 @@ impl AppConfig {
             enabled_tools: config.enabled_tools,
             visible_tools: config.visible_tools,
 
-            skills_enabled: config.skills_enabled,
-            enabled_skills: config.enabled_skills,
-            visible_skills: config.visible_skills,
-
             mcp_server_support: config.mcp_server_support,
             mapping_mcp_servers: config.mapping_mcp_servers,
             enabled_mcp_servers: config.enabled_mcp_servers,
@@ -391,14 +379,6 @@ impl AppConfig {
             self.enabled_tools = v;
         }
 
-        if let Some(Some(v)) = super::read_env_bool(&get_env_name("skills_enabled")) {
-            self.skills_enabled = v;
-        }
-        
-        if let Some(v) = super::read_env_value::<String>(&get_env_name("enabled_skills")) {
-            self.enabled_skills = v;
-        }
-
         if let Some(Some(v)) = super::read_env_bool(&get_env_name("mcp_server_support")) {
             self.mcp_server_support = v;
         }

src/config/install_remote.rs

@@ -24,7 +24,7 @@ pub fn install_remote(git_url: &str, filter: Option<InstallFilter>, force: bool)
     if layout.is_empty() {
         println!(
             "No recognized assets found in {git_url}. Expected one or more of: \
-             agents/, roles/, skills/, macros/, functions/tools/, functions/mcp.json"
+             agents/, roles/, macros/, functions/tools/, functions/mcp.json"
         );
         return Ok(());
     }
@@ -193,7 +193,6 @@ fn run_git(args: Vec<OsString>) -> Result<()> {
 struct RemoteLayout {
     agents: Option<PathBuf>,
     roles: Option<PathBuf>,
-    skills: Option<PathBuf>,
     macros: Option<PathBuf>,
     functions_tools: Option<PathBuf>,
     mcp_json: Option<PathBuf>,
@@ -203,7 +202,6 @@ impl RemoteLayout {
     fn is_empty(&self) -> bool {
         self.agents.is_none()
             && self.roles.is_none()
-            && self.skills.is_none()
             && self.macros.is_none()
             && self.functions_tools.is_none()
             && self.mcp_json.is_none()
@@ -217,29 +215,20 @@ fn scan_remote_layout(root: &Path) -> Result<RemoteLayout> {
     if agents.is_dir() {
         layout.agents = Some(agents);
     }
-
     let roles = root.join("roles");
     if roles.is_dir() {
         layout.roles = Some(roles);
     }
-
-    let skills = root.join("skills");
-    if skills.is_dir() {
-        layout.skills = Some(skills);
-    }
-
     let macros = root.join("macros");
     if macros.is_dir() {
         layout.macros = Some(macros);
     }
-
     let functions = root.join("functions");
     if functions.is_dir() {
         let tools = functions.join("tools");
         if tools.is_dir() {
             layout.functions_tools = Some(tools);
         }
-
         let mcp = functions.join("mcp.json");
         if mcp.is_file() {
             layout.mcp_json = Some(mcp);
@@ -262,10 +251,6 @@ fn apply_filter(mut layout: RemoteLayout, filter: Option<InstallFilter>) -> Remo
             roles: layout.roles.take(),
             ..RemoteLayout::default()
         },
-        InstallFilter::Skills => RemoteLayout {
-            skills: layout.skills.take(),
-            ..RemoteLayout::default()
-        },
         InstallFilter::Macros => RemoteLayout {
             macros: layout.macros.take(),
             ..RemoteLayout::default()
@@ -323,7 +308,6 @@ fn walk_files_inner(dir: &Path, out: &mut Vec<PathBuf>) -> Result<()> {
 enum TopCategory {
     Agents,
     Roles,
-    Skills,
     Macros,
     FunctionsTools,
 }
@@ -333,7 +317,6 @@ impl TopCategory {
         match self {
             TopCategory::Agents => "agents",
             TopCategory::Roles => "roles",
-            TopCategory::Skills => "skills",
             TopCategory::Macros => "macros",
             TopCategory::FunctionsTools => "functions/tools",
         }
@@ -373,11 +356,6 @@ fn plan_changes(layout: &RemoteLayout) -> Result<InstallPlan> {
     if let Some(src_dir) = &layout.roles {
         plan_dir_into(src_dir, &paths::roles_dir(), TopCategory::Roles, &mut files)?;
     }
-
-    if let Some(src_dir) = &layout.skills {
-        plan_dir_into(src_dir, &paths::skills_dir(), TopCategory::Skills, &mut files)?;
-    }
-
     if let Some(src_dir) = &layout.macros {
         plan_dir_into(
             src_dir,
@@ -479,7 +457,6 @@ fn print_plan_summary(plan: &InstallPlan) {
     for cat in [
         TopCategory::Agents,
         TopCategory::Roles,
-        TopCategory::Skills,
         TopCategory::Macros,
         TopCategory::FunctionsTools,
     ] {
@@ -1005,7 +982,6 @@ mod tests {
         let l = RemoteLayout {
             agents: Some(PathBuf::from("a")),
             roles: Some(PathBuf::from("r")),
-            skills: Some(PathBuf::from("s")),
             macros: Some(PathBuf::from("m")),
             functions_tools: Some(PathBuf::from("f")),
             mcp_json: Some(PathBuf::from("j")),
@@ -1013,8 +989,8 @@ mod tests {
 
         let out = apply_filter(l, None);
 
-        assert!(out.agents.is_some() && out.roles.is_some() && out.skills.is_some());
-        assert!(out.macros.is_some() && out.functions_tools.is_some() && out.mcp_json.is_some());
+        assert!(out.agents.is_some() && out.roles.is_some() && out.macros.is_some());
+        assert!(out.functions_tools.is_some() && out.mcp_json.is_some());
     }
 
     #[test]
@@ -1022,7 +998,6 @@ mod tests {
         let l = RemoteLayout {
             agents: Some(PathBuf::from("a")),
             roles: None,
-            skills: Some(PathBuf::from("s")),
             macros: None,
             functions_tools: Some(PathBuf::from("f")),
             mcp_json: Some(PathBuf::from("j")),
@@ -1031,7 +1006,6 @@ mod tests {
         let out = apply_filter(l, Some(InstallFilter::Functions));
 
         assert!(out.agents.is_none());
-        assert!(out.skills.is_none());
         assert_eq!(out.functions_tools, Some(PathBuf::from("f")));
         assert!(out.mcp_json.is_none());
     }
@@ -1041,7 +1015,6 @@ mod tests {
         let l = RemoteLayout {
             agents: Some(PathBuf::from("a")),
             roles: None,
-            skills: Some(PathBuf::from("s")),
             macros: None,
             functions_tools: Some(PathBuf::from("f")),
             mcp_json: Some(PathBuf::from("j")),
@@ -1049,7 +1022,7 @@ mod tests {
 
         let out = apply_filter(l, Some(InstallFilter::McpConfig));
 
-        assert!(out.agents.is_none() && out.skills.is_none() && out.functions_tools.is_none());
+        assert!(out.agents.is_none() && out.functions_tools.is_none());
         assert_eq!(out.mcp_json, Some(PathBuf::from("j")));
     }
 
@@ -1058,7 +1031,6 @@ mod tests {
         let l = RemoteLayout {
             agents: Some(PathBuf::from("a")),
             roles: Some(PathBuf::from("r")),
-            skills: Some(PathBuf::from("s")),
             macros: Some(PathBuf::from("m")),
             functions_tools: Some(PathBuf::from("f")),
             mcp_json: Some(PathBuf::from("j")),
@@ -1067,25 +1039,7 @@ mod tests {
         let out = apply_filter(l, Some(InstallFilter::Roles));
 
         assert_eq!(out.roles, Some(PathBuf::from("r")));
-        assert!(out.agents.is_none() && out.skills.is_none() && out.macros.is_none());
-        assert!(out.functions_tools.is_none() && out.mcp_json.is_none());
-    }
-
-    #[test]
-    fn apply_filter_skills_keeps_only_skills() {
-        let l = RemoteLayout {
-            agents: Some(PathBuf::from("a")),
-            roles: Some(PathBuf::from("r")),
-            skills: Some(PathBuf::from("s")),
-            macros: Some(PathBuf::from("m")),
-            functions_tools: Some(PathBuf::from("f")),
-            mcp_json: Some(PathBuf::from("j")),
-        };
-
-        let out = apply_filter(l, Some(InstallFilter::Skills));
-
-        assert_eq!(out.skills, Some(PathBuf::from("s")));
-        assert!(out.agents.is_none() && out.roles.is_none() && out.macros.is_none());
+        assert!(out.agents.is_none() && out.macros.is_none());
         assert!(out.functions_tools.is_none() && out.mcp_json.is_none());
     }
 
@@ -1130,10 +1084,8 @@ mod tests {
     #[test]
     fn scan_remote_layout_finds_known_subdirs() {
         let root = fresh_temp_dir("scan-test-");
-
         fs::create_dir_all(root.join("agents/sample")).unwrap();
         fs::create_dir_all(root.join("roles")).unwrap();
-        fs::create_dir_all(root.join("skills")).unwrap();
         fs::create_dir_all(root.join("macros")).unwrap();
         fs::create_dir_all(root.join("functions/tools")).unwrap();
         touch(&root.join("functions/mcp.json"));
@@ -1142,30 +1094,12 @@ mod tests {
         let layout = scan_remote_layout(&root).unwrap();
         assert!(layout.agents.is_some());
         assert!(layout.roles.is_some());
-        assert!(layout.skills.is_some());
         assert!(layout.macros.is_some());
         assert!(layout.functions_tools.is_some());
         assert!(layout.mcp_json.is_some());
         let _ = fs::remove_dir_all(&root);
     }
 
-    #[test]
-    fn scan_remote_layout_finds_skills_only() {
-        let root = fresh_temp_dir("scan-skills-only-");
-        fs::create_dir_all(root.join("skills/git-master")).unwrap();
-        touch(&root.join("skills/git-master/SKILL.md"));
-
-        let layout = scan_remote_layout(&root).unwrap();
-
-        assert!(layout.skills.is_some());
-        assert!(layout.agents.is_none());
-        assert!(layout.roles.is_none());
-        assert!(layout.macros.is_none());
-        assert!(layout.functions_tools.is_none());
-        assert!(layout.mcp_json.is_none());
-        let _ = fs::remove_dir_all(&root);
-    }
-
     #[test]
     fn scan_remote_layout_ignores_unrelated_files() {
         let root = fresh_temp_dir("scan-unrelated-");

src/config/mod.rs

@@ -11,9 +11,6 @@ mod rag_cache;
 mod request_context;
 mod role;
 mod session;
-mod skill;
-mod skill_policy;
-mod skill_registry;
 pub(crate) mod todo;
 mod tool_scope;
 mod update;
@@ -33,12 +30,6 @@ pub use self::role::{
     CODE_ROLE, CREATE_TITLE_ROLE, EXPLAIN_SHELL_ROLE, Role, RoleLike, SHELL_ROLE,
 };
 use self::session::Session;
-#[allow(unused_imports)]
-pub use self::skill::Skill;
-#[allow(unused_imports)]
-pub use self::skill_policy::SkillPolicy;
-#[allow(unused_imports)]
-pub use self::skill_registry::SkillRegistry;
 pub use self::update::run_self_update;
 use crate::client::{
     ClientConfig, MessageContentToolCalls, Model, ModelType, OPENAI_COMPATIBLE_PROVIDERS,
@@ -83,7 +74,6 @@ const LIGHT_THEME: &[u8] = include_bytes!("../../assets/monokai-extended-light.t
 const CONFIG_FILE_NAME: &str = "config.yaml";
 const AGENT_GRAPH_FILE_NAME: &str = "graph.yaml";
 const ROLES_DIR_NAME: &str = "roles";
-const SKILLS_DIR_NAME: &str = "skills";
 const MACROS_DIR_NAME: &str = "macros";
 const ENV_FILE_NAME: &str = ".env";
 const MESSAGES_FILE_NAME: &str = "messages.md";
@@ -154,10 +144,6 @@ pub struct Config {
     pub enabled_tools: Option<String>,
     pub visible_tools: Option<Vec<String>>,
 
-    pub skills_enabled: bool,
-    pub enabled_skills: Option<String>,
-    pub visible_skills: Option<Vec<String>>,
-
     pub mcp_server_support: bool,
     pub mapping_mcp_servers: IndexMap<String, String>,
     pub enabled_mcp_servers: Option<String>,
@@ -219,10 +205,6 @@ impl Default for Config {
             enabled_tools: None,
             visible_tools: None,
 
-            skills_enabled: true,
-            enabled_skills: None,
-            visible_skills: None,
-
             mcp_server_support: true,
             mapping_mcp_servers: Default::default(),
             enabled_mcp_servers: None,
@@ -268,7 +250,6 @@ pub fn install_builtins() -> Result<()> {
     Functions::install_builtin_global_tools(false)?;
     Agent::install_builtin_agents(false)?;
     Macro::install_macros(false)?;
-    Skill::install_builtin_skills(false)?;
     Ok(())
 }
 
@@ -277,20 +258,18 @@ pub enum AssetCategory {
     Agents,
     Macros,
     Functions,
-    Skills,
     #[value(name = "mcp_config")]
     McpConfig,
 }
 
 impl AssetCategory {
-    pub const NAMES: [&'static str; 5] = ["agents", "macros", "functions", "skills", "mcp_config"];
+    pub const NAMES: [&'static str; 4] = ["agents", "macros", "functions", "mcp_config"];
 
     pub fn parse(name: &str) -> Option<Self> {
         match name {
             "agents" => Some(Self::Agents),
             "macros" => Some(Self::Macros),
             "functions" => Some(Self::Functions),
-            "skills" => Some(Self::Skills),
             "mcp_config" => Some(Self::McpConfig),
             _ => None,
         }
@@ -301,7 +280,6 @@ impl AssetCategory {
 pub enum InstallFilter {
     Agents,
     Roles,
-    Skills,
     Macros,
     Functions,
     #[value(name = "mcp_config")]
@@ -309,20 +287,12 @@ pub enum InstallFilter {
 }
 
 impl InstallFilter {
-    pub const NAMES: [&'static str; 6] = [
-        "agents",
-        "roles",
-        "skills",
-        "macros",
-        "functions",
-        "mcp_config",
-    ];
+    pub const NAMES: [&'static str; 5] = ["agents", "roles", "macros", "functions", "mcp_config"];
 
     pub fn parse(name: &str) -> Option<Self> {
         match name {
             "agents" => Some(Self::Agents),
             "roles" => Some(Self::Roles),
-            "skills" => Some(Self::Skills),
             "macros" => Some(Self::Macros),
             "functions" => Some(Self::Functions),
             "mcp_config" => Some(Self::McpConfig),
@@ -336,7 +306,6 @@ pub fn install_assets(category: AssetCategory) -> Result<()> {
         AssetCategory::Agents => ("agents", paths::agents_data_dir()),
         AssetCategory::Macros => ("macros", paths::macros_dir()),
         AssetCategory::Functions => ("functions", paths::functions_dir()),
-        AssetCategory::Skills => ("skills", paths::skills_dir()),
         AssetCategory::McpConfig => ("MCP config", paths::mcp_config_file()),
     };
 
@@ -349,7 +318,6 @@ pub fn install_assets(category: AssetCategory) -> Result<()> {
         AssetCategory::Agents => Agent::install_builtin_agents(true)?,
         AssetCategory::Macros => Macro::install_macros(true)?,
         AssetCategory::Functions => Functions::install_builtin_global_tools(true)?,
-        AssetCategory::Skills => Skill::install_builtin_skills(true)?,
         AssetCategory::McpConfig => Functions::install_mcp_config()?,
     }
 

src/config/paths.rs

@@ -3,7 +3,7 @@ use super::{
     AGENT_GRAPH_FILE_NAME, AGENTS_DIR_NAME, BASH_PROMPT_UTILS_FILE_NAME, CONFIG_FILE_NAME,
     ENV_FILE_NAME, FUNCTIONS_BIN_DIR_NAME, FUNCTIONS_DIR_NAME, GLOBAL_TOOLS_DIR_NAME,
     GLOBAL_TOOLS_UTILS_DIR_NAME, MACROS_DIR_NAME, MCP_FILE_NAME, ModelsOverride, RAGS_DIR_NAME,
-    ROLES_DIR_NAME, SKILLS_DIR_NAME,
+    ROLES_DIR_NAME,
 };
 use crate::client::ProviderModels;
 use crate::utils::{get_env_name, list_file_names, normalize_env_name};
@@ -65,21 +65,6 @@ pub fn role_file(name: &str) -> PathBuf {
     roles_dir().join(format!("{name}.md"))
 }
 
-pub fn skills_dir() -> PathBuf {
-    match env::var(get_env_name("skills_dir")) {
-        Ok(value) => PathBuf::from(value),
-        Err(_) => local_path(SKILLS_DIR_NAME),
-    }
-}
-
-pub fn skill_dir(name: &str) -> PathBuf {
-    skills_dir().join(name)
-}
-
-pub fn skill_file(name: &str) -> PathBuf {
-    skill_dir(name).join("SKILL.md")
-}
-
 pub fn macros_dir() -> PathBuf {
     match env::var(get_env_name("macros_dir")) {
         Ok(value) => PathBuf::from(value),
@@ -249,28 +234,6 @@ pub fn has_macro(name: &str) -> bool {
     names.contains(&name.to_string())
 }
 
-pub fn list_skills() -> Vec<String> {
-    let mut names = Vec::new();
-    if let Ok(rd) = read_dir(skills_dir()) {
-        for entry in rd.flatten() {
-            if let Ok(file_type) = entry.file_type()
-                && file_type.is_dir()
-                && let Some(name) = entry.file_name().to_str()
-                && entry.path().join("SKILL.md").is_file()
-            {
-                names.push(name.to_string());
-            }
-        }
-    }
-
-    names.sort_unstable();
-    names
-}
-
-pub fn has_skill(name: &str) -> bool {
-    skill_file(name).is_file()
-}
-
 pub fn local_models_override() -> Result<Vec<ProviderModels>> {
     let model_override_path = models_override_file();
     let err = || {

src/config/request_context.rs

@@ -1,8 +1,5 @@
 use super::rag_cache::{RagCache, RagKey};
 use super::session::Session;
-use super::skill::{SKILL_SCAFFOLD, Skill};
-use super::skill_policy::SkillPolicy;
-use super::skill_registry::SkillRegistry;
 use super::todo::TodoList;
 use super::tool_scope::{McpRuntime, ToolScope};
 use super::{
@@ -37,7 +34,7 @@ use indexmap::IndexMap;
 use indoc::formatdoc;
 use inquire::{Confirm, MultiSelect, Text, list_option::ListOption, validator::Validation};
 use parking_lot::RwLock;
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::fs::{File, OpenOptions, read_dir, read_to_string, remove_dir_all, remove_file};
 use std::io::Write;
 use std::path::{Path, PathBuf};
@@ -85,7 +82,6 @@ pub struct RequestContext {
     pub current_depth: usize,
     pub auto_continue_count: usize,
     pub todo_list: TodoList,
-    pub skill_registry: SkillRegistry,
     pub last_continuation_response: Option<String>,
 
     pub render_mode: RenderMode,
@@ -114,7 +110,6 @@ impl RequestContext {
             current_depth: 0,
             auto_continue_count: 0,
             todo_list: TodoList::default(),
-            skill_registry: SkillRegistry::default(),
             last_continuation_response: None,
             render_mode: RenderMode::default(),
         }
@@ -162,7 +157,6 @@ impl RequestContext {
             current_depth: 0,
             auto_continue_count: 0,
             todo_list: TodoList::default(),
-            skill_registry: SkillRegistry::default(),
             last_continuation_response: None,
             render_mode: RenderMode::default(),
         })
@@ -204,7 +198,6 @@ impl RequestContext {
             current_depth: self.current_depth,
             auto_continue_count: 0,
             todo_list: self.todo_list.clone(),
-            skill_registry: self.skill_registry.clone(),
             last_continuation_response: None,
             render_mode: self.render_mode,
         }
@@ -244,7 +237,6 @@ impl RequestContext {
             current_depth,
             auto_continue_count: 0,
             todo_list: TodoList::default(),
-            skill_registry: SkillRegistry::default(),
             last_continuation_response: None,
             render_mode: parent.render_mode,
         }
@@ -619,7 +611,7 @@ impl RequestContext {
             }
         }
 
-        self.skill_registry.effective_role(&role)
+        role
     }
 
     pub fn auto_continue_config(&self) -> AutoContinueConfig {
@@ -822,7 +814,6 @@ impl RequestContext {
         if !app.dry_run {
             self.save_message(app, input, output)?;
         }
-        self.skill_registry.sweep_auto_unload();
         Ok(())
     }
 
@@ -1546,7 +1537,6 @@ impl RequestContext {
             "session" => (self.sessions_dir(), Some(".yaml")),
             "rag" => (paths::rags_dir(), Some(".yaml")),
             "macro" => (paths::macros_dir(), Some(".yaml")),
-            "skill" => (paths::skills_dir(), None),
             "agent-data" => (paths::agents_data_dir(), None),
             _ => bail!("Unknown kind '{kind}'"),
         };
@@ -1872,16 +1862,6 @@ impl RequestContext {
                     super::map_completion_values(values)
                 }
                 ".macro" => super::map_completion_values(paths::list_macros()),
-                ".skill" => {
-                    let mut values: Vec<String> = vec![
-                        "loaded".to_string(),
-                        "load".to_string(),
-                        "unload".to_string(),
-                        "edit".to_string(),
-                    ];
-                    values.extend(paths::list_skills());
-                    super::map_completion_values(values)
-                }
                 ".starter" => match &self.agent {
                     Some(agent) => agent
                         .conversation_starters()
@@ -1924,7 +1904,6 @@ impl RequestContext {
                     "session",
                     "rag",
                     "macro",
-                    "skill",
                     "agent-data",
                 ]),
                 ".vault" => {
@@ -2082,35 +2061,6 @@ impl RequestContext {
         enabled_mcp_servers: Option<String>,
         abort_signal: AbortSignal,
     ) -> Result<()> {
-        let policy = SkillPolicy::effective(
-            app,
-            self.role.as_ref(),
-            self.agent.as_ref(),
-            self.session.as_ref(),
-        )?;
-
-        let enabled_mcp_servers = if policy.skills_enabled && app.mcp_server_support {
-            let skill_mcps = self.skill_registry.loaded_mcp_servers();
-            match (enabled_mcp_servers.as_deref(), skill_mcps.is_empty()) {
-                (Some("all"), _) | (_, true) => enabled_mcp_servers,
-                (base, false) => {
-                    let mut merged: BTreeSet<String> = skill_mcps;
-                    if let Some(s) = base {
-                        for token in s.split(',') {
-                            let t = token.trim();
-                            if !t.is_empty() {
-                                merged.insert(t.to_string());
-                            }
-                        }
-                    }
-
-                    Some(merged.into_iter().collect::<Vec<_>>().join(","))
-                }
-            }
-        } else {
-            enabled_mcp_servers
-        };
-
         let mut mcp_runtime = McpRuntime::new();
 
         if app.mcp_server_support
@@ -2178,9 +2128,6 @@ impl RequestContext {
         if !mcp_runtime.is_empty() {
             functions.append_mcp_meta_functions(mcp_runtime.server_names());
         }
-        if app.function_calling_support && policy.skills_enabled {
-            functions.append_skill_functions();
-        }
 
         let tool_tracker = self.tool_scope.tool_tracker.clone();
         self.tool_scope = ToolScope {
@@ -2191,30 +2138,6 @@ impl RequestContext {
         Ok(())
     }
 
-    pub async fn refresh_tool_scope(&mut self, abort_signal: AbortSignal) -> Result<()> {
-        let app = (*self.app.config).clone();
-        let base_mcps = if app.mcp_server_support {
-            if let Some(session) = &self.session {
-                session.enabled_mcp_servers()
-            } else if let Some(agent) = &self.agent {
-                let names = agent.mcp_server_names();
-                if names.is_empty() {
-                    None
-                } else {
-                    Some(names.join(","))
-                }
-            } else if let Some(role) = &self.role {
-                role.enabled_mcp_servers()
-            } else {
-                app.enabled_mcp_servers.clone()
-            }
-        } else {
-            None
-        };
-
-        self.rebuild_tool_scope(&app, base_mcps, abort_signal).await
-    }
-
     pub async fn use_role(
         &mut self,
         app: &AppConfig,
@@ -2487,112 +2410,6 @@ impl RequestContext {
         Ok(())
     }
 
-    pub fn upsert_skill(&self, app: &AppConfig, name: &str) -> Result<()> {
-        let path = paths::skill_file(name);
-        ensure_parent_exists(&path)?;
-        let is_new = !path.exists();
-        if is_new {
-            fs::write(&path, SKILL_SCAFFOLD).with_context(|| {
-                format!("Failed to scaffold skill at {}", path.display())
-            })?;
-        }
-        let editor = app.editor()?;
-        edit_file(&editor, &path)?;
-        if is_new {
-            println!("✓ Created skill at '{}'.", path.display());
-        } else {
-            println!("✓ Saved skill at '{}'.", path.display());
-        }
-        Ok(())
-    }
-
-    pub async fn load_skill_repl(
-        &mut self,
-        name: &str,
-        abort_signal: AbortSignal,
-    ) -> Result<()> {
-        if !paths::has_skill(name) {
-            bail!(
-                "Skill '{name}' is not installed (expected at {})",
-                paths::skill_file(name).display()
-            );
-        }
-
-        let policy = SkillPolicy::effective(
-            &self.app.config,
-            self.role.as_ref(),
-            self.agent.as_ref(),
-            self.session.as_ref(),
-        )?;
-
-        if !policy.skills_enabled {
-            bail!("Skills are disabled in this context");
-        }
-
-        if !policy.allows(name) {
-            bail!("Skill '{name}' is not enabled in this context");
-        }
-
-        let skill = Skill::load(name)?;
-        let fn_on = self.app.config.function_calling_support;
-        let mcp_on = self.app.config.mcp_server_support;
-        let needs_tools = skill
-            .enabled_tools()
-            .map(|s| !s.trim().is_empty())
-            .unwrap_or(false);
-        let needs_mcps = skill
-            .enabled_mcp_servers()
-            .map(|s| !s.trim().is_empty())
-            .unwrap_or(false);
-
-        if needs_tools && !fn_on {
-            bail!("Skill '{name}' requires function calling, which is disabled");
-        }
-
-        if needs_mcps && !mcp_on {
-            bail!("Skill '{name}' requires MCP servers, which are disabled");
-        }
-
-        self.skill_registry.insert(skill)?;
-        if let Err(e) = self.refresh_tool_scope(abort_signal).await {
-            let _ = self.skill_registry.unload(name);
-            bail!("Loaded skill '{name}' but failed to refresh tool scope: {e}");
-        }
-
-        println!("✓ Loaded skill '{name}'.");
-        Ok(())
-    }
-
-    pub async fn unload_skill_repl(
-        &mut self,
-        name: &str,
-        abort_signal: AbortSignal,
-    ) -> Result<()> {
-        self.skill_registry.unload(name)?;
-
-        if let Err(e) = self.refresh_tool_scope(abort_signal).await {
-            eprintln!(
-                "Warning: unloaded skill '{name}' but tool scope refresh failed: {e}"
-            );
-        }
-
-        println!("✓ Unloaded skill '{name}'.");
-        Ok(())
-    }
-
-    pub fn list_loaded_skills(&self) {
-        let names = self.skill_registry.loaded_names();
-
-        if names.is_empty() {
-            println!("No skills loaded.");
-        } else {
-            println!("Loaded skills:");
-            for name in names {
-                println!("  • {name}");
-            }
-        }
-    }
-
     pub async fn apply_prelude(
         &mut self,
         app: &AppConfig,
@@ -3516,58 +3333,6 @@ mod tests {
         assert!(lm.continuous);
     }
 
-    #[test]
-    fn after_chat_completion_sweeps_auto_unload_skills_at_turn_end() {
-        let mut ctx = create_test_ctx();
-        ctx.app = Arc::new(AppState {
-            config: Arc::new(AppConfig {
-                dry_run: true,
-                ..(*ctx.app.config).clone()
-            }),
-            ..(*ctx.app).clone()
-        });
-
-        let ephemeral = Skill::new("ephemeral", "---\nauto_unload: true\n---\nbody");
-        let persistent = Skill::new("persistent", "---\nauto_unload: false\n---\nbody");
-        ctx.skill_registry.insert(ephemeral).unwrap();
-        ctx.skill_registry.insert(persistent).unwrap();
-
-        let input = Input::from_str(&ctx, "hello", None);
-        let app = Arc::clone(&ctx.app.config);
-        ctx.after_chat_completion(app.as_ref(), &input, "response", &[]).unwrap();
-
-        assert!(!ctx.skill_registry.is_loaded("ephemeral"));
-        assert!(ctx.skill_registry.is_loaded("persistent"));
-    }
-
-    #[test]
-    fn after_chat_completion_preserves_auto_unload_during_tool_loop() {
-        let mut ctx = create_test_ctx();
-        ctx.app = Arc::new(AppState {
-            config: Arc::new(AppConfig {
-                dry_run: true,
-                ..(*ctx.app.config).clone()
-            }),
-            ..(*ctx.app).clone()
-        });
-
-        let ephemeral = Skill::new("ephemeral", "---\nauto_unload: true\n---\nbody");
-        ctx.skill_registry.insert(ephemeral).unwrap();
-
-        let input = Input::from_str(&ctx, "hello", None);
-        let app = Arc::clone(&ctx.app.config);
-        let tool_result = ToolResult::new(
-            crate::function::ToolCall::default(),
-            serde_json::json!({}),
-        );
-        ctx.after_chat_completion(app.as_ref(), &input, "", &[tool_result]).unwrap();
-
-        assert!(
-            ctx.skill_registry.is_loaded("ephemeral"),
-            "auto_unload skills must persist through tool-using rounds"
-        );
-    }
-
     #[test]
     fn role_like_mut_returns_none_when_empty() {
         let mut ctx = create_test_ctx();
@@ -4072,43 +3837,6 @@ mod tests {
         );
     }
 
-    #[test]
-    #[serial]
-    fn install_builtin_skills_force_overwrites_only_with_force() {
-        let _guard = TestConfigDirGuard::new();
-
-        Skill::install_builtin_skills(false).unwrap();
-        let file = paths::skill_file("git-master");
-        assert!(file.exists(), "git-master skill should be installed");
-
-        write(&file, "SENTINEL").unwrap();
-        Skill::install_builtin_skills(false).unwrap();
-        assert_eq!(
-            read_to_string(&file).unwrap(),
-            "SENTINEL",
-            "non-force install must not overwrite an existing skill"
-        );
-
-        Skill::install_builtin_skills(true).unwrap();
-        assert_ne!(
-            read_to_string(&file).unwrap(),
-            "SENTINEL",
-            "force install must overwrite the existing skill"
-        );
-    }
-
-    #[test]
-    #[serial]
-    fn install_builtin_skills_installs_all_bundled() {
-        let _guard = TestConfigDirGuard::new();
-
-        Skill::install_builtin_skills(false).unwrap();
-        assert!(paths::skill_file("git-master").exists());
-        assert!(paths::skill_file("ai-slop-remover").exists());
-        assert!(paths::skill_file("code-review").exists());
-        assert!(paths::skill_file("frontend-ui-ux").exists());
-    }
-
     #[test]
     #[serial]
     fn install_functions_force_preserves_user_mcp_json() {

src/config/role.rs

@@ -56,10 +56,6 @@ pub struct Role {
     #[serde(skip_serializing_if = "Option::is_none")]
     enabled_mcp_servers: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    skills_enabled: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    enabled_skills: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     auto_continue: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     max_auto_continues: Option<usize>,
@@ -102,10 +98,6 @@ impl Role {
                     "enabled_mcp_servers" => {
                         role.enabled_mcp_servers = value.as_str().map(|v| v.to_string())
                     }
-                    "skills_enabled" => role.skills_enabled = value.as_bool(),
-                    "enabled_skills" => {
-                        role.enabled_skills = value.as_str().map(|v| v.to_string())
-                    }
                     "auto_continue" => role.auto_continue = value.as_bool(),
                     "max_auto_continues" => {
                         role.max_auto_continues = value.as_u64().map(|v| v as usize)
@@ -155,12 +147,6 @@ impl Role {
         if let Some(enabled_mcp_servers) = self.enabled_mcp_servers() {
             metadata.push(format!("enabled_mcp_servers: {enabled_mcp_servers}"));
         }
-        if let Some(skills_enabled) = self.skills_enabled {
-            metadata.push(format!("skills_enabled: {skills_enabled}"));
-        }
-        if let Some(enabled_skills) = &self.enabled_skills {
-            metadata.push(format!("enabled_skills: {enabled_skills}"));
-        }
         if let Some(auto_continue) = self.auto_continue {
             metadata.push(format!("auto_continue: {auto_continue}"));
         }
@@ -285,14 +271,6 @@ impl Role {
         self.continuation_prompt.as_deref()
     }
 
-    pub fn skills_enabled(&self) -> Option<bool> {
-        self.skills_enabled
-    }
-
-    pub fn enabled_skills(&self) -> Option<&str> {
-        self.enabled_skills.as_deref()
-    }
-
     pub fn append_to_prompt(&mut self, text: &str) {
         self.prompt.push_str(text);
     }

src/config/session.rs

@@ -29,10 +29,6 @@ pub struct Session {
     #[serde(skip_serializing_if = "Option::is_none")]
     enabled_mcp_servers: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    skills_enabled: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    enabled_skills: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     save_session: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     compression_threshold: Option<usize>,
@@ -79,14 +75,6 @@ pub struct Session {
 }
 
 impl Session {
-    pub fn skills_enabled(&self) -> Option<bool> {
-        self.skills_enabled
-    }
-
-    pub fn enabled_skills(&self) -> Option<&str> {
-        self.enabled_skills.as_deref()
-    }
-
     pub fn new_from_ctx(ctx: &RequestContext, app: &AppConfig, name: &str) -> Self {
         let role = ctx.extract_role(app);
         let mut session = Self {

src/config/skill.rs

@@ -1,329 +0,0 @@
-use super::*;
-
-use anyhow::Result;
-use fancy_regex::Regex;
-use rust_embed::Embed;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::sync::LazyLock;
-use log::{debug, info};
-
-#[derive(Embed)]
-#[folder = "assets/skills/"]
-struct SkillsAsset;
-
-static RE_METADATA: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"(?s)-{3,}\s*(.*?)\s*-{3,}\s*(.*)").unwrap());
-
-pub const SKILL_SCAFFOLD: &str = "\
----
-description: One-line description shown to the model when listing skills.
-enabled_tools:
-enabled_mcp_servers:
-auto_unload: false
----
-Replace this body with the knowledge or methodology this skill teaches.
-";
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct Skill {
-    name: String,
-    #[serde(default)]
-    description: String,
-    #[serde(default)]
-    body: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    enabled_tools: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    enabled_mcp_servers: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    auto_unload: Option<bool>,
-}
-
-impl Skill {
-    pub fn new(name: &str, content: &str) -> Self {
-        let mut metadata = "";
-        let mut body = content.trim();
-        if let Ok(Some(caps)) = RE_METADATA.captures(content)
-            && let (Some(metadata_value), Some(body_value)) = (caps.get(1), caps.get(2))
-        {
-            metadata = metadata_value.as_str().trim();
-            body = body_value.as_str().trim();
-        }
-        let mut body = body.to_string();
-        interpolate_variables(&mut body);
-        let mut skill = Self {
-            name: name.to_string(),
-            body,
-            ..Default::default()
-        };
-        if !metadata.is_empty()
-            && let Ok(value) = serde_yaml::from_str::<Value>(metadata)
-            && let Some(value) = value.as_object()
-        {
-            for (key, value) in value {
-                match key.as_str() {
-                    "description" => {
-                        if let Some(v) = value.as_str() {
-                            skill.description = v.to_string();
-                        }
-                    }
-                    "enabled_tools" => {
-                        skill.enabled_tools = value.as_str().map(|v| v.to_string());
-                    }
-                    "enabled_mcp_servers" => {
-                        skill.enabled_mcp_servers = value.as_str().map(|v| v.to_string());
-                    }
-                    "auto_unload" => {
-                        skill.auto_unload = value.as_bool();
-                    }
-                    _ => (),
-                }
-            }
-        }
-        skill
-    }
-
-    pub fn install_builtin_skills(force: bool) -> Result<()> {
-        info!(
-            "Installing built-in skills in {}",
-            paths::skills_dir().display()
-        );
-
-        for file in SkillsAsset::iter() {
-            debug!("Processing skill file: {}", file.as_ref());
-
-            let embedded_file = SkillsAsset::get(&file).ok_or_else(|| {
-                anyhow!("Failed to load embedded skill file: {}", file.as_ref())
-            })?;
-            let content = unsafe { std::str::from_utf8_unchecked(&embedded_file.data) };
-            let file_path = paths::skills_dir().join(file.as_ref());
-
-            if file_path.exists() && !force {
-                debug!(
-                    "Skill file already exists, skipping: {}",
-                    file_path.display()
-                );
-                continue;
-            }
-
-            ensure_parent_exists(&file_path)?;
-            info!("Creating skill file: {}", file_path.display());
-            let mut skill_file = File::create(&file_path)?;
-            Write::write_all(&mut skill_file, content.as_bytes())?;
-        }
-
-        Ok(())
-    }
-
-    pub fn load(name: &str) -> Result<Self> {
-        let path = paths::skill_file(name);
-        let content = read_to_string(&path).with_context(|| {
-            format!("Failed to read skill '{name}' at {}", path.display())
-        })?;
-        Ok(Skill::new(name, &content))
-    }
-
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    pub fn description(&self) -> &str {
-        &self.description
-    }
-
-    pub fn body(&self) -> &str {
-        &self.body
-    }
-
-    pub fn enabled_tools(&self) -> Option<&str> {
-        self.enabled_tools.as_deref()
-    }
-
-    pub fn enabled_mcp_servers(&self) -> Option<&str> {
-        self.enabled_mcp_servers.as_deref()
-    }
-
-    pub fn auto_unload(&self) -> bool {
-        self.auto_unload.unwrap_or(false)
-    }
-
-    pub fn is_compatible(&self, function_calling_enabled: bool, mcp_enabled: bool) -> bool {
-        if self.declares_tools() && !function_calling_enabled {
-            return false;
-        }
-        
-        if self.declares_mcp_servers() && !mcp_enabled {
-            return false;
-        }
-
-        true
-    }
-
-    fn declares_tools(&self) -> bool {
-        self.enabled_tools
-            .as_deref()
-            .map(|s| !s.trim().is_empty())
-            .unwrap_or(false)
-    }
-
-    fn declares_mcp_servers(&self) -> bool {
-        self.enabled_mcp_servers
-            .as_deref()
-            .map(|s| !s.trim().is_empty())
-            .unwrap_or(false)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn skill_new_parses_body() {
-        let skill = Skill::new("test", "You are a git expert");
-
-        assert_eq!(skill.name(), "test");
-        assert_eq!(skill.body(), "You are a git expert");
-        assert_eq!(skill.description(), "");
-    }
-
-    #[test]
-    fn skill_new_parses_full_metadata() {
-        let content = "---\n\
-            description: Atomic commits, rebase surgery\n\
-            enabled_tools: shell,fs\n\
-            enabled_mcp_servers: github\n\
-            auto_unload: true\n\
-            ---\n\
-            You are a git expert";
-
-        let skill = Skill::new("git-master", content);
-
-        assert_eq!(skill.name(), "git-master");
-        assert_eq!(skill.description(), "Atomic commits, rebase surgery");
-        assert_eq!(skill.enabled_tools(), Some("shell,fs"));
-        assert_eq!(skill.enabled_mcp_servers(), Some("github"));
-        assert!(skill.auto_unload());
-        assert_eq!(skill.body(), "You are a git expert");
-    }
-
-    #[test]
-    fn skill_new_no_metadata_has_defaults() {
-        let skill = Skill::new("test", "Just a body");
-
-        assert_eq!(skill.description(), "");
-        assert_eq!(skill.enabled_tools(), None);
-        assert_eq!(skill.enabled_mcp_servers(), None);
-        assert!(!skill.auto_unload());
-    }
-
-    #[test]
-    fn skill_new_metadata_only() {
-        let content = "---\ndescription: Just metadata\n---";
-
-        let skill = Skill::new("test", content);
-
-        assert_eq!(skill.description(), "Just metadata");
-        assert_eq!(skill.body(), "");
-    }
-
-    #[test]
-    fn skill_new_partial_metadata_leaves_others_none() {
-        let content = "---\ndescription: Partial\n---\nthe body";
-
-        let skill = Skill::new("test", content);
-
-        assert_eq!(skill.description(), "Partial");
-        assert_eq!(skill.enabled_tools(), None);
-        assert_eq!(skill.enabled_mcp_servers(), None);
-        assert!(!skill.auto_unload());
-        assert_eq!(skill.body(), "the body");
-    }
-
-    #[test]
-    fn skill_new_ignores_unknown_keys() {
-        let content = "---\ndescription: D\nbogus_field: 42\n---\nbody";
-
-        let skill = Skill::new("test", content);
-
-        assert_eq!(skill.description(), "D");
-        assert_eq!(skill.body(), "body");
-    }
-
-    #[test]
-    fn skill_new_trims_body_whitespace() {
-        let content = "---\ndescription: D\n---\n\n\n  body content  \n\n";
-
-        let skill = Skill::new("test", content);
-
-        assert_eq!(skill.body(), "body content");
-    }
-
-    #[test]
-    fn skill_default_has_empty_fields() {
-        let skill = Skill::default();
-
-        assert_eq!(skill.name(), "");
-        assert_eq!(skill.body(), "");
-        assert_eq!(skill.description(), "");
-        assert_eq!(skill.enabled_tools(), None);
-        assert_eq!(skill.enabled_mcp_servers(), None);
-        assert!(!skill.auto_unload());
-    }
-
-    #[test]
-    fn is_compatible_knowledge_only_passes_all_combinations() {
-        let skill = Skill::new("test", "Just knowledge");
-
-        assert!(skill.is_compatible(false, false));
-        assert!(skill.is_compatible(true, false));
-        assert!(skill.is_compatible(false, true));
-        assert!(skill.is_compatible(true, true));
-    }
-
-    #[test]
-    fn is_compatible_with_tools_requires_function_calling() {
-        let content = "---\nenabled_tools: shell\n---\nbody";
-
-        let skill = Skill::new("test", content);
-
-        assert!(!skill.is_compatible(false, true));
-        assert!(!skill.is_compatible(false, false));
-        assert!(skill.is_compatible(true, true));
-        assert!(skill.is_compatible(true, false));
-    }
-
-    #[test]
-    fn is_compatible_with_mcp_requires_mcp_enabled() {
-        let content = "---\nenabled_mcp_servers: github\n---\nbody";
-
-        let skill = Skill::new("test", content);
-
-        assert!(!skill.is_compatible(true, false));
-        assert!(!skill.is_compatible(false, false));
-        assert!(skill.is_compatible(true, true));
-    }
-
-    #[test]
-    fn is_compatible_requires_both_when_both_declared() {
-        let content =
-            "---\nenabled_tools: shell\nenabled_mcp_servers: github\n---\nbody";
-
-        let skill = Skill::new("test", content);
-
-        assert!(!skill.is_compatible(true, false));
-        assert!(!skill.is_compatible(false, true));
-        assert!(!skill.is_compatible(false, false));
-        assert!(skill.is_compatible(true, true));
-    }
-
-    #[test]
-    fn is_compatible_empty_string_tools_is_knowledge_only() {
-        let content = "---\nenabled_tools: \"\"\n---\nbody";
-
-        let skill = Skill::new("test", content);
-
-        assert!(skill.is_compatible(false, false));
-    }
-}

src/config/skill_policy.rs

@@ -1,362 +0,0 @@
-use super::agent::Agent;
-use super::app_config::AppConfig;
-use super::paths;
-use super::role::Role;
-use super::session::Session;
-
-use anyhow::{Result, bail};
-use std::collections::HashSet;
-
-#[derive(Debug)]
-pub struct SkillPolicy {
-    pub skills_enabled: bool,
-    pub enabled: HashSet<String>,
-}
-
-impl SkillPolicy {
-    pub fn effective(
-        global: &AppConfig,
-        role: Option<&Role>,
-        agent: Option<&Agent>,
-        session: Option<&Session>,
-    ) -> Result<Self> {
-        Self::effective_with(
-            global,
-            role,
-            agent,
-            session,
-            &paths::has_skill,
-            &paths::list_skills,
-        )
-    }
-
-    fn effective_with<F, G>(
-        global: &AppConfig,
-        role: Option<&Role>,
-        agent: Option<&Agent>,
-        session: Option<&Session>,
-        skill_exists: &F,
-        list_installed: &G,
-    ) -> Result<Self>
-    where
-        F: Fn(&str) -> bool,
-        G: Fn() -> Vec<String>,
-    {
-        let mut skills_enabled = global.skills_enabled;
-        if let Some(r) = role
-            && let Some(false) = r.skills_enabled()
-        {
-            skills_enabled = false;
-        }
-
-        if let Some(a) = agent
-            && let Some(false) = a.skills_enabled()
-        {
-            skills_enabled = false;
-        }
-
-        if let Some(s) = session
-            && let Some(false) = s.skills_enabled()
-        {
-            skills_enabled = false;
-        }
-
-        let visible: Option<HashSet<String>> = global
-            .visible_skills
-            .as_ref()
-            .map(|v| v.iter().cloned().collect());
-
-        let enabled_raw: Option<Vec<String>> = session
-            .and_then(|s| parse_csv_opt(s.enabled_skills()))
-            .or_else(|| agent.and_then(|a| a.enabled_skills().map(|v| v.to_vec())))
-            .or_else(|| role.and_then(|r| parse_csv_opt(r.enabled_skills())))
-            .or_else(|| parse_csv_opt(global.enabled_skills.as_deref()));
-
-        let enabled: HashSet<String> = match enabled_raw {
-            Some(explicit) => {
-                let set: HashSet<String> = explicit.into_iter().collect();
-                for name in &set {
-                    if !skill_exists(name) {
-                        bail!("enabled_skills references skill '{name}' which is not installed");
-                    }
-
-                    if let Some(vs) = &visible
-                        && !vs.contains(name)
-                    {
-                        bail!(
-                            "enabled_skills references skill '{name}' which is not in visible_skills"
-                        );
-                    }
-                }
-                set
-            }
-            None => match &visible {
-                Some(v) => v.clone(),
-                None => list_installed().into_iter().collect(),
-            },
-        };
-
-        Ok(Self {
-            skills_enabled,
-            enabled,
-        })
-    }
-
-    pub fn allows(&self, name: &str) -> bool {
-        self.skills_enabled && self.enabled.contains(name)
-    }
-}
-
-fn parse_csv_opt(s: Option<&str>) -> Option<Vec<String>> {
-    s.map(|raw| {
-        raw.split(',')
-            .map(|t| t.trim().to_string())
-            .filter(|t| !t.is_empty())
-            .collect()
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn always_true(_: &str) -> bool {
-        true
-    }
-
-    fn empty_installed() -> Vec<String> {
-        Vec::new()
-    }
-
-    fn make_app_config(
-        skills_enabled: bool,
-        enabled: Option<&str>,
-        visible: Option<&[&str]>,
-    ) -> AppConfig {
-        AppConfig {
-            skills_enabled,
-            enabled_skills: enabled.map(|s| s.to_string()),
-            visible_skills: visible.map(|v| v.iter().map(|s| s.to_string()).collect()),
-            ..AppConfig::default()
-        }
-    }
-
-    #[test]
-    fn defaults_yield_skills_enabled_with_empty_universe() {
-        let global = AppConfig::default();
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(policy.skills_enabled);
-        assert!(policy.enabled.is_empty());
-    }
-
-    #[test]
-    fn falls_back_to_all_installed_when_no_level_sets_enabled_skills() {
-        let global = AppConfig::default();
-        let installed = || vec!["alpha".to_string(), "beta".to_string()];
-
-        let policy =
-            SkillPolicy::effective_with(&global, None, None, None, &always_true, &installed)
-                .unwrap();
-
-        assert_eq!(policy.enabled.len(), 2);
-        assert!(policy.enabled.contains("alpha"));
-        assert!(policy.enabled.contains("beta"));
-    }
-
-    #[test]
-    fn falls_back_to_visible_when_visible_set_but_no_enabled() {
-        let global = make_app_config(true, None, Some(&["alpha", "beta"]));
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert_eq!(policy.enabled.len(), 2);
-        assert!(policy.enabled.contains("alpha"));
-        assert!(policy.enabled.contains("beta"));
-    }
-
-    #[test]
-    fn global_enabled_skills_is_effective_when_no_other_levels() {
-        let global = make_app_config(true, Some("alpha,beta"), Some(&["alpha", "beta", "gamma"]));
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(policy.enabled.contains("alpha"));
-        assert!(policy.enabled.contains("beta"));
-        assert!(!policy.enabled.contains("gamma"));
-    }
-
-    #[test]
-    fn role_overrides_global_enabled_skills() {
-        let global = make_app_config(true, Some("alpha"), Some(&["alpha", "beta"]));
-        let role = Role::new(
-            "test",
-            "---\nenabled_skills: beta\n---\nbody",
-        );
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            Some(&role),
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(policy.enabled.contains("beta"));
-        assert!(!policy.enabled.contains("alpha"));
-    }
-
-    #[test]
-    fn any_skills_enabled_false_disables_globally() {
-        let global = make_app_config(true, None, None);
-        let role = Role::new("test", "---\nskills_enabled: false\n---\nbody");
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            Some(&role),
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(!policy.skills_enabled);
-    }
-
-    #[test]
-    fn allows_returns_false_when_skills_disabled() {
-        let global = AppConfig {
-            skills_enabled: false,
-            ..AppConfig::default()
-        };
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &always_true,
-            &|| vec!["alpha".to_string()],
-        )
-        .unwrap();
-
-        assert!(!policy.allows("alpha"));
-    }
-
-    #[test]
-    fn allows_returns_true_when_skill_in_enabled_set() {
-        let global = make_app_config(true, Some("alpha"), None);
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(policy.allows("alpha"));
-        assert!(!policy.allows("beta"));
-    }
-
-    #[test]
-    fn validation_rejects_uninstalled_skill_reference() {
-        let global = make_app_config(true, Some("ghost"), None);
-
-        let err = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &|_| false,
-            &empty_installed,
-        )
-        .unwrap_err();
-
-        assert!(err.to_string().contains("not installed"));
-        assert!(err.to_string().contains("ghost"));
-    }
-
-    #[test]
-    fn validation_rejects_skill_not_in_visible_set() {
-        let global = make_app_config(true, Some("beta"), Some(&["alpha"]));
-
-        let err = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap_err();
-
-        assert!(err.to_string().contains("not in visible_skills"));
-        assert!(err.to_string().contains("beta"));
-    }
-
-    #[test]
-    fn validation_skipped_when_no_explicit_enabled_skills() {
-        let global = make_app_config(true, None, None);
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            None,
-            None,
-            None,
-            &|_| false,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(policy.enabled.is_empty());
-    }
-
-    #[test]
-    fn empty_string_enabled_skills_resolves_to_empty_override() {
-        let global = make_app_config(true, Some("alpha,beta"), Some(&["alpha", "beta"]));
-        let role = Role::new("test", "---\nenabled_skills: \"\"\n---\nbody");
-
-        let policy = SkillPolicy::effective_with(
-            &global,
-            Some(&role),
-            None,
-            None,
-            &always_true,
-            &empty_installed,
-        )
-        .unwrap();
-
-        assert!(policy.enabled.is_empty());
-    }
-}

src/config/skill_registry.rs

@@ -1,340 +0,0 @@
-use super::role::{Role, RoleLike};
-use super::skill::Skill;
-
-use anyhow::{Result, bail};
-use indexmap::IndexMap;
-use std::collections::BTreeSet;
-
-#[derive(Clone, Default)]
-pub struct SkillRegistry {
-    loaded: IndexMap<String, Skill>,
-}
-
-#[allow(dead_code)]
-impl SkillRegistry {
-    pub fn new() -> Self {
-        Self {
-            loaded: IndexMap::new(),
-        }
-    }
-
-    pub fn load(&mut self, name: &str) -> Result<()> {
-        if self.loaded.contains_key(name) {
-            bail!("Skill '{name}' is already loaded");
-        }
-        let skill = Skill::load(name)?;
-        self.loaded.insert(name.to_string(), skill);
-
-        Ok(())
-    }
-
-    pub fn insert(&mut self, skill: Skill) -> Result<()> {
-        let name = skill.name().to_string();
-
-        if self.loaded.contains_key(&name) {
-            bail!("Skill '{name}' is already loaded");
-        }
-
-        self.loaded.insert(name, skill);
-
-        Ok(())
-    }
-
-    pub fn unload(&mut self, name: &str) -> Result<()> {
-        if self.loaded.shift_remove(name).is_none() {
-            bail!("Skill '{name}' is not loaded");
-        }
-
-        Ok(())
-    }
-
-    pub fn loaded_names(&self) -> Vec<String> {
-        self.loaded.keys().cloned().collect()
-    }
-
-    pub fn loaded_mcp_servers(&self) -> BTreeSet<String> {
-        let mut out = BTreeSet::new();
-        for skill in self.loaded.values() {
-            if let Some(csv) = skill.enabled_mcp_servers() {
-                for token in csv.split(',') {
-                    let t = token.trim();
-                    if !t.is_empty() {
-                        out.insert(t.to_string());
-                    }
-                }
-            }
-        }
-        out
-    }
-
-    pub fn is_loaded(&self, name: &str) -> bool {
-        self.loaded.contains_key(name)
-    }
-
-    pub fn sweep_auto_unload(&mut self) {
-        self.loaded.retain(|_, skill| !skill.auto_unload());
-    }
-
-    pub fn effective_role(&self, base: &Role) -> Role {
-        if self.loaded.is_empty() {
-            return base.clone();
-        }
-
-        let mut effective = base.clone();
-        let skip_body = effective.is_embedded_prompt();
-
-        let base_tools_set = effective.enabled_tools().is_some();
-        let base_mcps_set = effective.enabled_mcp_servers().is_some();
-
-        let mut tools = parse_csv(effective.enabled_tools().as_deref());
-        let mut mcps = parse_csv(effective.enabled_mcp_servers().as_deref());
-
-        for (_, skill) in &self.loaded {
-            tools.extend(parse_csv(skill.enabled_tools()));
-            mcps.extend(parse_csv(skill.enabled_mcp_servers()));
-            if !skip_body && !skill.body().is_empty() {
-                let separator = if effective.is_empty_prompt() { "" } else { "\n\n" };
-                effective.append_to_prompt(separator);
-                effective.append_to_prompt(skill.body());
-            }
-        }
-
-        if base_tools_set || !tools.is_empty() {
-            effective.set_enabled_tools(Some(join_csv(&tools)));
-        }
-
-        if base_mcps_set || !mcps.is_empty() {
-            effective.set_enabled_mcp_servers(Some(join_csv(&mcps)));
-        }
-
-        effective
-    }
-}
-
-fn parse_csv(s: Option<&str>) -> BTreeSet<String> {
-    let mut set = BTreeSet::new();
-    if let Some(raw) = s {
-        for token in raw.split(',') {
-            let trimmed = token.trim();
-            if !trimmed.is_empty() {
-                set.insert(trimmed.to_string());
-            }
-        }
-    }
-    set
-}
-
-fn join_csv(set: &BTreeSet<String>) -> String {
-    set.iter().cloned().collect::<Vec<_>>().join(",")
-}
-
-#[cfg(test)]
-impl SkillRegistry {
-    fn insert_for_test(&mut self, skill: Skill) {
-        self.loaded.insert(skill.name().to_string(), skill);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn make_skill(name: &str, frontmatter: &str, body: &str) -> Skill {
-        let content = if frontmatter.is_empty() {
-            body.to_string()
-        } else {
-            format!("---\n{frontmatter}\n---\n{body}")
-        };
-        Skill::new(name, &content)
-    }
-
-    #[test]
-    fn empty_registry_returns_base_clone() {
-        let base = Role::new("test", "You are a helper");
-        let registry = SkillRegistry::new();
-
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.prompt(), base.prompt());
-    }
-
-    #[test]
-    fn one_skill_appends_body_after_base_with_separator() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("git-master", "description: D", "Git knowledge"));
-
-        let base = Role::new("test", "You are a helper");
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.prompt(), "You are a helper\n\nGit knowledge");
-    }
-
-    #[test]
-    fn two_skills_compose_bodies_in_insertion_order() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("a", "", "Alpha body"));
-        registry.insert_for_test(make_skill("b", "", "Beta body"));
-
-        let base = Role::new("test", "Base");
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.prompt(), "Base\n\nAlpha body\n\nBeta body");
-    }
-
-    #[test]
-    fn empty_base_prompt_omits_leading_separator() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("a", "", "Alpha"));
-        registry.insert_for_test(make_skill("b", "", "Beta"));
-
-        let base = Role::new("test", "");
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.prompt(), "Alpha\n\nBeta");
-    }
-
-    #[test]
-    fn embedded_prompt_base_skips_body_composition() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill(
-            "git-master",
-            "enabled_tools: shell",
-            "should not appear",
-        ));
-
-        let base = Role::new("test", "Process: __INPUT__");
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.prompt(), "Process: __INPUT__");
-        let tools = effective.enabled_tools().expect("tools set by skill");
-        assert!(tools.contains("shell"));
-    }
-
-    #[test]
-    fn skills_with_empty_body_do_not_inject_separator() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("knowledge", "enabled_tools: fs", ""));
-
-        let base = Role::new("test", "Base");
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.prompt(), "Base");
-    }
-
-    #[test]
-    fn tools_and_mcps_are_unioned_and_deduplicated() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill(
-            "a",
-            "enabled_tools: shell,fs\nenabled_mcp_servers: github",
-            "body",
-        ));
-        registry.insert_for_test(make_skill(
-            "b",
-            "enabled_tools: fs,git\nenabled_mcp_servers: github,jira",
-            "body",
-        ));
-
-        let mut base = Role::new("test", "body");
-        base.set_enabled_tools(Some("web_search".to_string()));
-
-        let effective = registry.effective_role(&base);
-
-        let tools_str = effective.enabled_tools().unwrap();
-        let tools: BTreeSet<&str> = tools_str.split(',').collect();
-        assert_eq!(
-            tools,
-            BTreeSet::from(["fs", "git", "shell", "web_search"])
-        );
-
-        let mcps_str = effective.enabled_mcp_servers().unwrap();
-        let mcps: BTreeSet<&str> = mcps_str.split(',').collect();
-        assert_eq!(mcps, BTreeSet::from(["github", "jira"]));
-    }
-
-    #[test]
-    fn no_skill_tool_contributions_preserves_base_none() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("knowledge", "", "Pure knowledge"));
-
-        let base = Role::new("test", "Base");
-        let effective = registry.effective_role(&base);
-
-        assert!(effective.enabled_tools().is_none());
-        assert!(effective.enabled_mcp_servers().is_none());
-    }
-
-    #[test]
-    fn base_some_empty_tools_is_preserved() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("knowledge", "", "Pure knowledge"));
-
-        let mut base = Role::new("test", "Base");
-        base.set_enabled_tools(Some(String::new()));
-        let effective = registry.effective_role(&base);
-
-        assert_eq!(effective.enabled_tools().as_deref(), Some(""));
-    }
-
-    #[test]
-    fn load_already_loaded_returns_error() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("git-master", "", "body"));
-
-        let err = registry.load("git-master").unwrap_err();
-
-        assert!(err.to_string().contains("already loaded"));
-    }
-
-    #[test]
-    fn unload_not_loaded_returns_error() {
-        let mut registry = SkillRegistry::new();
-
-        let err = registry.unload("missing").unwrap_err();
-
-        assert!(err.to_string().contains("not loaded"));
-    }
-
-    #[test]
-    fn unload_existing_succeeds_and_removes() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("git-master", "", "body"));
-        assert!(registry.is_loaded("git-master"));
-
-        registry.unload("git-master").unwrap();
-        assert!(!registry.is_loaded("git-master"));
-    }
-
-    #[test]
-    fn loaded_names_returns_insertion_order() {
-        let mut registry = SkillRegistry::new();
-
-        registry.insert_for_test(make_skill("zulu", "", "body"));
-        registry.insert_for_test(make_skill("alpha", "", "body"));
-        registry.insert_for_test(make_skill("mike", "", "body"));
-
-        assert_eq!(
-            registry.loaded_names(),
-            vec!["zulu".to_string(), "alpha".to_string(), "mike".to_string()]
-        );
-    }
-
-    #[test]
-    fn sweep_removes_only_auto_unload_skills() {
-        let mut registry = SkillRegistry::new();
-        registry.insert_for_test(make_skill("ephemeral", "auto_unload: true", "body"));
-        registry.insert_for_test(make_skill("persistent", "", "body"));
-
-        registry.sweep_auto_unload();
-
-        assert!(!registry.is_loaded("ephemeral"));
-        assert!(registry.is_loaded("persistent"));
-    }
-
-    #[test]
-    fn is_loaded_returns_false_for_unknown() {
-        let registry = SkillRegistry::new();
-
-        assert!(!registry.is_loaded("nothing"));
-    }
-}

src/function/mod.rs

@@ -1,4 +1,3 @@
-pub(crate) mod skill;
 pub(crate) mod supervisor;
 pub(crate) mod todo;
 pub(crate) mod user_interaction;
@@ -33,7 +32,6 @@ use std::{
     process::{Command, Stdio},
 };
 use strum_macros::AsRefStr;
-use skill::SKILL_FUNCTION_PREFIX;
 use supervisor::SUPERVISOR_FUNCTION_PREFIX;
 use todo::TODO_FUNCTION_PREFIX;
 use user_interaction::USER_FUNCTION_PREFIX;
@@ -355,11 +353,6 @@ impl Functions {
         self.declarations.extend(todo::todo_function_declarations());
     }
 
-    pub fn append_skill_functions(&mut self) {
-        self.declarations
-            .extend(skill::skill_function_declarations());
-    }
-
     pub fn append_supervisor_functions(&mut self) {
         self.declarations
             .extend(supervisor::supervisor_function_declarations());
@@ -1046,15 +1039,6 @@ impl ToolCall {
                     json!({"tool_call_error": error_msg})
                 })
             }
-            _ if cmd_name.starts_with(SKILL_FUNCTION_PREFIX) => {
-                skill::handle_skill_tool(ctx, &cmd_name, &json_data)
-                    .await
-                    .unwrap_or_else(|e| {
-                        let error_msg = format!("Skill tool failed: {e}");
-                        eprintln!("{}", warning_text(&format!("⚠️ {error_msg} ⚠️")));
-                        json!({"tool_call_error": error_msg})
-                    })
-            }
             _ if cmd_name.starts_with(SUPERVISOR_FUNCTION_PREFIX) => {
                 supervisor::handle_supervisor_tool(ctx, &cmd_name, &json_data)
                     .await

src/function/skill.rs

@@ -1,311 +0,0 @@
-use super::{FunctionDeclaration, JsonSchema};
-use crate::config::{RequestContext, Skill, SkillPolicy, paths};
-use crate::utils::create_abort_signal;
-
-use anyhow::{Result, bail};
-use indexmap::IndexMap;
-use log::warn;
-use serde_json::{Value, json};
-
-pub const SKILL_FUNCTION_PREFIX: &str = "skill__";
-
-pub fn skill_function_declarations() -> Vec<FunctionDeclaration> {
-    vec![
-        FunctionDeclaration {
-            name: format!("{SKILL_FUNCTION_PREFIX}list"),
-            description:
-                "List skills available in this context. Returns each skill's name, description, \
-                 what tools and MCP servers it grants on load, and whether it is currently loaded. \
-                 Call this to discover skills before using skill__load."
-                    .to_string(),
-            parameters: JsonSchema {
-                type_value: Some("object".to_string()),
-                properties: Some(IndexMap::new()),
-                ..Default::default()
-            },
-            agent: false,
-        },
-        FunctionDeclaration {
-            name: format!("{SKILL_FUNCTION_PREFIX}load"),
-            description:
-                "Load a skill module into the current context. The skill's instructions and any \
-                 tools or MCP servers it grants become active for subsequent turns. Call \
-                 skill__unload when the skill's work is complete to keep the context lean."
-                    .to_string(),
-            parameters: JsonSchema {
-                type_value: Some("object".to_string()),
-                properties: Some(IndexMap::from([(
-                    "name".to_string(),
-                    JsonSchema {
-                        type_value: Some("string".to_string()),
-                        description: Some("Name of the skill to load.".into()),
-                        ..Default::default()
-                    },
-                )])),
-                required: Some(vec!["name".to_string()]),
-                ..Default::default()
-            },
-            agent: false,
-        },
-        FunctionDeclaration {
-            name: format!("{SKILL_FUNCTION_PREFIX}unload"),
-            description:
-                "Unload a previously loaded skill, removing its instructions and granted tools \
-                 from the context. Call this when the skill's work is complete."
-                    .to_string(),
-            parameters: JsonSchema {
-                type_value: Some("object".to_string()),
-                properties: Some(IndexMap::from([(
-                    "name".to_string(),
-                    JsonSchema {
-                        type_value: Some("string".to_string()),
-                        description: Some("Name of the skill to unload.".into()),
-                        ..Default::default()
-                    },
-                )])),
-                required: Some(vec!["name".to_string()]),
-                ..Default::default()
-            },
-            agent: false,
-        },
-    ]
-}
-
-pub async fn handle_skill_tool(
-    ctx: &mut RequestContext,
-    cmd_name: &str,
-    args: &Value,
-) -> Result<Value> {
-    let action = cmd_name
-        .strip_prefix(SKILL_FUNCTION_PREFIX)
-        .unwrap_or(cmd_name);
-
-    let policy = SkillPolicy::effective(
-        &ctx.app.config,
-        ctx.role.as_ref(),
-        ctx.agent.as_ref(),
-        ctx.session.as_ref(),
-    )?;
-
-    if !policy.skills_enabled {
-        return Ok(json!({
-            "error": "Skills are disabled in this context"
-        }));
-    }
-
-    match action {
-        "list" => handle_list(ctx, &policy),
-        "load" => handle_load(ctx, args, &policy).await,
-        "unload" => handle_unload(ctx, args).await,
-        _ => bail!("Unknown skill action: {action}"),
-    }
-}
-
-fn handle_list(ctx: &RequestContext, policy: &SkillPolicy) -> Result<Value> {
-    let function_calling_on = ctx.app.config.function_calling_support;
-    let mcp_on = ctx.app.config.mcp_server_support;
-
-    let mut entries = Vec::new();
-    for name in paths::list_skills() {
-        if !policy.allows(&name) {
-            continue;
-        }
-
-        let skill = match Skill::load(&name) {
-            Ok(s) => s,
-            Err(e) => {
-                warn!("Failed to load skill '{name}' for listing: {e}");
-                continue;
-            }
-        };
-        if !skill.is_compatible(function_calling_on, mcp_on) {
-            warn!(
-                "Skill '{name}' filtered from list: declares tools or MCP servers but those features are disabled"
-            );
-            continue;
-        }
-
-        entries.push(json!({
-            "name": skill.name(),
-            "description": skill.description(),
-            "grants_tools": csv_to_vec(skill.enabled_tools()),
-            "grants_mcp_servers": csv_to_vec(skill.enabled_mcp_servers()),
-            "loaded": ctx.skill_registry.is_loaded(skill.name()),
-        }));
-    }
-
-    Ok(json!({"skills": entries}))
-}
-
-async fn handle_load(
-    ctx: &mut RequestContext,
-    args: &Value,
-    policy: &SkillPolicy,
-) -> Result<Value> {
-    let name = match args.get("name").and_then(Value::as_str) {
-        Some(n) if !n.is_empty() => n,
-        _ => return Ok(json!({"error": "name is required"})),
-    };
-
-    if !policy.allows(name) {
-        return Ok(json!({
-            "error": format!("Skill '{name}' is not enabled in this context")
-        }));
-    }
-
-    let skill = match Skill::load(name) {
-        Ok(s) => s,
-        Err(e) => {
-            return Ok(json!({
-                "error": format!("Failed to load skill '{name}': {e}")
-            }));
-        }
-    };
-
-    let function_calling_on = ctx.app.config.function_calling_support;
-    let mcp_on = ctx.app.config.mcp_server_support;
-
-    let tools_declared = skill
-        .enabled_tools()
-        .map(|s| !s.trim().is_empty())
-        .unwrap_or(false);
-    let mcps_declared = skill
-        .enabled_mcp_servers()
-        .map(|s| !s.trim().is_empty())
-        .unwrap_or(false);
-
-    if tools_declared && !function_calling_on {
-        return Ok(json!({
-            "error": format!(
-                "Skill '{name}' requires function calling, which is disabled in this context"
-            )
-        }));
-    }
-    if mcps_declared && !mcp_on {
-        return Ok(json!({
-            "error": format!(
-                "Skill '{name}' requires MCP servers, which are disabled in this context"
-            )
-        }));
-    }
-
-    if let Err(e) = ctx.skill_registry.insert(skill) {
-        return Ok(json!({"error": e.to_string()}));
-    }
-
-    if let Err(e) = ctx.refresh_tool_scope(create_abort_signal()).await {
-        let _ = ctx.skill_registry.unload(name);
-        return Ok(json!({
-            "error": format!("Loaded skill '{name}' but failed to refresh tool scope: {e}")
-        }));
-    }
-
-    Ok(json!({
-        "status": "ok",
-        "loaded": name,
-        "message": format!("Skill '{name}' loaded")
-    }))
-}
-
-async fn handle_unload(ctx: &mut RequestContext, args: &Value) -> Result<Value> {
-    let name = match args.get("name").and_then(Value::as_str) {
-        Some(n) if !n.is_empty() => n,
-        _ => return Ok(json!({"error": "name is required"})),
-    };
-
-    if let Err(e) = ctx.skill_registry.unload(name) {
-        return Ok(json!({"error": e.to_string()}));
-    }
-
-    if let Err(e) = ctx.refresh_tool_scope(create_abort_signal()).await {
-        warn!("Unloaded skill '{name}' but failed to refresh tool scope: {e}");
-    }
-
-    Ok(json!({
-        "status": "ok",
-        "unloaded": name
-    }))
-}
-
-fn csv_to_vec(csv: Option<&str>) -> Vec<String> {
-    csv.map(|raw| {
-        raw.split(',')
-            .map(|t| t.trim().to_string())
-            .filter(|t| !t.is_empty())
-            .collect()
-    })
-    .unwrap_or_default()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn declarations_have_three_entries() {
-        let decls = skill_function_declarations();
-        assert_eq!(decls.len(), 3);
-    }
-
-    #[test]
-    fn declaration_names_use_skill_prefix() {
-        let decls = skill_function_declarations();
-
-        let names: Vec<&str> = decls.iter().map(|d| d.name.as_str()).collect();
-
-        assert!(names.contains(&"skill__list"));
-        assert!(names.contains(&"skill__load"));
-        assert!(names.contains(&"skill__unload"));
-    }
-
-    #[test]
-    fn load_and_unload_require_name_parameter() {
-        let decls = skill_function_declarations();
-        for action in ["load", "unload"] {
-            let decl = decls
-                .iter()
-                .find(|d| d.name == format!("skill__{action}"))
-                .expect("missing declaration");
-
-            let required = decl
-                .parameters
-                .required
-                .as_ref()
-                .expect("required field missing");
-
-            assert!(required.contains(&"name".to_string()));
-        }
-    }
-
-    #[test]
-    fn list_has_no_required_parameters() {
-        let decls = skill_function_declarations();
-        let list_decl = decls
-            .iter()
-            .find(|d| d.name == "skill__list")
-            .expect("skill__list missing");
-
-        let required = list_decl
-            .parameters
-            .required
-            .as_ref()
-            .map(|v| v.is_empty())
-            .unwrap_or(true);
-
-        assert!(required, "skill__list should have no required parameters");
-    }
-
-    #[test]
-    fn csv_to_vec_empty_input() {
-        assert!(csv_to_vec(None).is_empty());
-        assert!(csv_to_vec(Some("")).is_empty());
-        assert!(csv_to_vec(Some("   ")).is_empty());
-    }
-
-    #[test]
-    fn csv_to_vec_parses_and_trims() {
-        let v = csv_to_vec(Some("a, b ,c,, d"));
-
-        assert_eq!(v, vec!["a", "b", "c", "d"]);
-    }
-}

src/main.rs

@@ -74,7 +74,6 @@ async fn main() -> Result<()> {
         || cli.list_agents
         || cli.list_rags
         || cli.list_macros
-        || cli.list_skills
         || cli.list_sessions;
     let vault_flags = cli.add_secret.is_some()
         || cli.get_secret.is_some()
@@ -192,24 +191,6 @@ async fn run(
         println!("{macros}");
         return Ok(());
     }
-    if cli.list_skills {
-        let skills = paths::list_skills().join("\n");
-        println!("{skills}");
-        return Ok(());
-    }
-    if cli.skill.len() == 1 && !paths::has_skill(&cli.skill[0]) {
-        let name = &cli.skill[0];
-        let app = Arc::clone(&ctx.app.config);
-        ctx.upsert_skill(app.as_ref(), name)?;
-        return Ok(());
-    }
-    if cli.skill.len() > 1 {
-        for name in &cli.skill {
-            if !paths::has_skill(name) {
-                bail!("Skill '{name}' is not installed");
-            }
-        }
-    }
 
     if cli.dry_run {
         update_app_config(&mut ctx, |app| app.dry_run = true);
@@ -323,10 +304,6 @@ async fn run(
             .await?;
     }
 
-    for name in &cli.skill {
-        ctx.load_skill_repl(name, abort_signal.clone()).await?;
-    }
-
     match is_repl {
         false => {
             let mut input = create_input(&ctx, text, &cli.file, abort_signal.clone()).await?;

src/repl/mod.rs

@@ -46,7 +46,7 @@ pub const DEFAULT_CONTINUATION_PROMPT: &str = indoc! {"
     4. Continue with the next pending item now. Call tools immediately."
 };
 
-static REPL_COMMANDS: LazyLock<[ReplCommand; 43]> = LazyLock::new(|| {
+static REPL_COMMANDS: LazyLock<[ReplCommand; 42]> = LazyLock::new(|| {
     [
         ReplCommand::new(".help", "Show this help guide", AssertState::pass()),
         ReplCommand::new(".info", "Show system info", AssertState::pass()),
@@ -191,11 +191,6 @@ static REPL_COMMANDS: LazyLock<[ReplCommand; 43]> = LazyLock::new(|| {
             AssertState::TrueFalse(StateFlags::RAG, StateFlags::AGENT),
         ),
         ReplCommand::new(".macro", "Execute a macro", AssertState::pass()),
-        ReplCommand::new(
-            ".skill",
-            "List, load, unload, edit, or create skills",
-            AssertState::pass(),
-        ),
         ReplCommand::new(
             ".file",
             "Include files, directories, URLs or commands",
@@ -518,54 +513,6 @@ pub async fn run_repl_command(
     .role <name> [text]...          # Temporarily switch to the role, send the text, and switch back"#
                 ),
             },
-            ".skill" => {
-                let trimmed = args.map(str::trim).unwrap_or("");
-                let mut parts = trimmed.splitn(2, char::is_whitespace);
-                let first = parts.next().unwrap_or("");
-                let rest = parts.next().map(str::trim).unwrap_or("");
-                match first {
-                    "" => println!(
-                        r#"Usage:
-    .skill loaded                   # List currently-loaded skills
-    .skill load <name>              # Load a skill into the current context
-    .skill unload <name>            # Unload a loaded skill
-    .skill edit <name>              # Open an existing skill in $EDITOR
-    .skill <name>                   # Open the skill in $EDITOR; create with a scaffold if missing"#
-                    ),
-                    "loaded" => ctx.list_loaded_skills(),
-                    "load" => {
-                        if rest.is_empty() {
-                            println!("Usage: .skill load <name>");
-                        } else {
-                            ctx.load_skill_repl(rest, abort_signal.clone()).await?;
-                        }
-                    }
-                    "unload" => {
-                        if rest.is_empty() {
-                            println!("Usage: .skill unload <name>");
-                        } else {
-                            ctx.unload_skill_repl(rest, abort_signal.clone()).await?;
-                        }
-                    }
-                    "edit" => {
-                        if rest.is_empty() {
-                            println!("Usage: .skill edit <name>");
-                        } else if !paths::has_skill(rest) {
-                            bail!(
-                                "Skill '{rest}' is not installed (expected at {})",
-                                paths::skill_file(rest).display()
-                            );
-                        } else {
-                            let app = Arc::clone(&ctx.app.config);
-                            ctx.upsert_skill(app.as_ref(), rest)?;
-                        }
-                    }
-                    name => {
-                        let app = Arc::clone(&ctx.app.config);
-                        ctx.upsert_skill(app.as_ref(), name)?;
-                    }
-                }
-            }
             ".session" => {
                 if let Some(name) = graph::active_agent_graph_name(ctx) {
                     bail!(
@@ -832,7 +779,7 @@ pub async fn run_repl_command(
                     ctx.delete(args)?;
                 }
                 _ => {
-                    println!("Usage: .delete <role|session|rag|macro|skill|agent-data>")
+                    println!("Usage: .delete <role|session|rag|macro|agent-data>")
                 }
             },
             ".copy" => {
@@ -1318,8 +1265,8 @@ mod tests {
     }
 
     #[test]
-    fn repl_commands_has_43_entries() {
-        assert_eq!(REPL_COMMANDS.len(), 43);
+    fn repl_commands_has_42_entries() {
+        assert_eq!(REPL_COMMANDS.len(), 42);
     }
 
     #[test]