Agent Profiles and Skills System

class AgentSafety(StrEnum):
    SAFE = auto()         # Read-only, no modifications
    NEUTRAL = auto()      # Default, requires approval
    DESTRUCTIVE = auto()  # Auto-approves some write operations
    YOLO = auto()         # Auto-approves everything

class AgentType(StrEnum):
    AGENT = auto()      # Primary agent (user-switchable)
    SUBAGENT = auto()   # Subagent (used by Task tool only)

class BuiltinAgentName(StrEnum):
    DEFAULT = "default"
    PLAN = "plan"
    ACCEPT_EDITS = "accept-edits"
    AUTO_APPROVE = "auto-approve"
    EXPLORE = "explore"

@dataclass(frozen=True)
class AgentProfile:
    name: str
    display_name: str
    description: str
    safety: AgentSafety
    agent_type: AgentType = AgentType.AGENT
    overrides: dict[str, Any] = field(default_factory=dict)

class AgentManager:
    def __init__(
        self,
        config_getter: Callable[[], VibeConfig],
        initial_agent: str = BuiltinAgentName.DEFAULT,
    ) -> None:

@staticmethod
def _compute_search_paths(config: VibeConfig) -> list[Path]:
    paths: list[Path] = []
 
    # 1. Config-specified paths
    for path in config.agent_paths:
        if path.is_dir():
            paths.append(path)
 
    # 2. Project-local .vibe/agents/ (trust-aware)
    if (agents_dir := resolve_local_agents_dir(Path.cwd())) is not None:
        paths.append(agents_dir)
 
    # 3. Global ~/.vibe/agents/
    if GLOBAL_AGENTS_DIR.path.is_dir():
        paths.append(GLOBAL_AGENTS_DIR.path)
 
    return unique_paths

# ~/.vibe/agents/my-agent.toml
display_name = "My Custom Agent"
description = "A custom agent with specific settings"
safety = "neutral"
agent_type = "agent"
 
# Config overrides (any valid VibeConfig fields)
auto_approve = false
active_model = "devstral-small"
 
[tools.bash]
permission = "always"
timeout = 120

---
name: my-skill
description: "What this skill does and when to use it"
license: MIT
compatibility: "Requires Node.js 18+"
user-invocable: true
allowed-tools: "bash read_file write_file"
metadata:
  author: "Your Name"
  version: "1.0"
---
 
# Skill Instructions
 
This content is injected into the system prompt when the skill is active.
The LLM will see these instructions and follow them.

class SkillMetadata(BaseModel):
    name: str              # Lowercase, hyphens only (pattern: ^[a-z0-9]+(-[a-z0-9]+)*$)
    description: str       # What this skill does (max 1024 chars)
    license: str | None    # License name
    compatibility: str | None  # Environment requirements
    metadata: dict[str, str]   # Arbitrary key-value pairs
    allowed_tools: list[str]   # Pre-approved tools (space-delimited string or list)
    user_invocable: bool = True  # Whether it appears in slash command menu

class SkillInfo(BaseModel):
    name: str
    description: str
    license: str | None = None
    compatibility: str | None = None
    metadata: dict[str, str]
    allowed_tools: list[str]
    user_invocable: bool = True
    skill_path: Path           # Absolute path to SKILL.md
 
    @property
    def skill_dir(self) -> Path:
        return self.skill_path.parent.resolve()

class SkillManager:
    def __init__(self, config_getter: Callable[[], VibeConfig]) -> None:

@staticmethod
def _compute_search_paths(config: VibeConfig) -> list[Path]:
    paths: list[Path] = []
 
    # 1. Config-specified paths
    for path in config.skill_paths:
        if path.is_dir():
            paths.append(path)
 
    # 2. Project-local .vibe/skills/ (trust-aware)
    if (skills_dir := resolve_local_skills_dir(Path.cwd())) is not None:
        paths.append(skills_dir)
 
    # 3. Global ~/.vibe/skills/
    if GLOBAL_SKILLS_DIR.path.is_dir():
        paths.append(GLOBAL_SKILLS_DIR.path)
 
    return unique_paths

@property
def available_skills(self) -> dict[str, SkillInfo]:
    if self._config.enabled_skills:
        return {name: info for name, info in self._available.items()
                if name_matches(name, self._config.enabled_skills)}
    if self._config.disabled_skills:
        return {name: info for name, info in self._available.items()
                if not name_matches(name, self._config.disabled_skills)}
    return dict(self._available)

def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
    """Parse YAML frontmatter delimited by --- markers."""
    # Splits on --- boundaries
    # Returns (yaml_dict, markdown_body)