@orderful/droid 0.14.0 → 0.16.0

package/src/commands/uninstall.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
-import { uninstallSkill } from '../lib/skills.js';
-import { getBundledTools, isToolInstalled } from '../lib/tools.js';
+import { uninstallSkill } from '../lib/skills';
+import { getBundledTools, isToolInstalled } from '../lib/tools';
 
 export async function uninstallCommand(toolName: string): Promise<void> {
   const tools = getBundledTools();

package/src/commands/update.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
-import { getVersion } from '../lib/version.js';
+import { getVersion } from '../lib/version';
 
 interface UpdateOptions {
   tools?: boolean;

package/src/index.ts

@@ -1,5 +1,5 @@
 // Re-export types and utilities for potential programmatic usage
-export * from './lib/types.js';
-export * from './lib/config.js';
-export * from './lib/skills.js';
-export * from './lib/version.js';
+export * from './lib/types';
+export * from './lib/config';
+export * from './lib/skills';
+export * from './lib/version';

package/src/lib/agents.ts

@@ -2,9 +2,10 @@ import { existsSync, readdirSync, readFileSync, writeFileSync, unlinkSync, mkdir
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
-import { loadConfig } from './config.js';
-import { Platform } from './types.js';
-import { getAgentsPath } from './platforms.js';
+import { loadConfig } from './config';
+import { Platform } from './types';
+import { getAgentsPath } from './platforms';
+import { loadToolManifest } from './tools';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const BUNDLED_TOOLS_DIR = join(__dirname, '../tools');
@@ -33,23 +34,58 @@ export interface AgentManifest {
 }
 
 /**
- * Load an agent manifest from an agent directory
+ * Parse YAML frontmatter from agent file content
  */
-export function loadAgentManifest(agentDir: string): AgentManifest | null {
-  const manifestPath = join(agentDir, 'AGENT.yaml');
-
-  if (!existsSync(manifestPath)) {
+function parseAgentFrontmatter(content: string): Record<string, unknown> | null {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith('---')) {
     return null;
   }
-
+  const endMatch = trimmed.slice(3).indexOf('---');
+  if (endMatch === -1) {
+    return null;
+  }
+  const frontmatterContent = trimmed.slice(3, 3 + endMatch);
   try {
-    const content = readFileSync(manifestPath, 'utf-8');
-    return YAML.parse(content) as AgentManifest;
+    return YAML.parse(frontmatterContent);
   } catch {
     return null;
   }
 }
 
+/**
+ * Load an agent manifest from an agent file (agents/{name}.md)
+ * Reads frontmatter from the .md file, version from TOOL.yaml
+ */
+export function loadAgentManifest(agentPath: string): AgentManifest | null {
+  if (!existsSync(agentPath)) {
+    return null;
+  }
+
+  const content = readFileSync(agentPath, 'utf-8');
+  const frontmatter = parseAgentFrontmatter(content);
+
+  if (!frontmatter || !frontmatter.name) {
+    return null;
+  }
+
+  // Get version from TOOL.yaml
+  // agentPath is tools/{tool}/agents/{name}.md, toolDir is tools/{tool}
+  const toolDir = dirname(dirname(agentPath));
+  const toolManifest = loadToolManifest(toolDir);
+
+  return {
+    name: frontmatter.name as string,
+    description: frontmatter.description as string || '',
+    version: toolManifest?.version || '0.0.0',
+    status: toolManifest?.status as 'alpha' | 'beta' | 'stable' | undefined,
+    mode: frontmatter.mode as 'primary' | 'subagent' | 'all' | undefined,
+    model: frontmatter.model as string | undefined,
+    color: frontmatter.color as string | undefined,
+    tools: frontmatter.tools as string[] | undefined,
+  };
+}
+
 /**
  * Get all bundled agents from tools
  */
@@ -61,7 +97,7 @@ export function getBundledAgents(): AgentManifest[] {
     return agents;
   }
 
-  // Get agents from tools/*/agents/
+  // Get agents from tools/*/agents/*.md
   const toolDirs = readdirSync(BUNDLED_TOOLS_DIR, { withFileTypes: true })
     .filter((dirent) => dirent.isDirectory())
     .map((dirent) => dirent.name);
@@ -70,12 +106,12 @@ export function getBundledAgents(): AgentManifest[] {
     const toolAgentsDir = join(BUNDLED_TOOLS_DIR, toolName, 'agents');
     if (!existsSync(toolAgentsDir)) continue;
 
-    const agentDirs = readdirSync(toolAgentsDir, { withFileTypes: true })
-      .filter((dirent) => dirent.isDirectory())
+    const agentFiles = readdirSync(toolAgentsDir, { withFileTypes: true })
+      .filter((dirent) => dirent.isFile() && dirent.name.endsWith('.md'))
       .map((dirent) => dirent.name);
 
-    for (const agentDir of agentDirs) {
-      const manifest = loadAgentManifest(join(toolAgentsDir, agentDir));
+    for (const agentFile of agentFiles) {
+      const manifest = loadAgentManifest(join(toolAgentsDir, agentFile));
       if (manifest && !seenNames.has(manifest.name)) {
         agents.push(manifest);
         seenNames.add(manifest.name);
@@ -166,35 +202,23 @@ function generateOpenCodeAgent(manifest: AgentManifest, agentContent: string): s
 }
 
 /**
- * Install an agent from a specific path
+ * Install an agent from a specific path (agents/{name}.md)
  * Generates the appropriate format based on the configured AI tool
  */
-export function installAgentFromPath(agentDir: string, agentName: string): { success: boolean; message: string } {
+export function installAgentFromPath(agentPath: string, agentName: string): { success: boolean; message: string } {
   const config = loadConfig();
-  const manifestPath = join(agentDir, 'AGENT.yaml');
-  const contentPath = join(agentDir, 'AGENT.md');
 
-  if (!existsSync(manifestPath)) {
+  // Load manifest from agent file frontmatter
+  const manifest = loadAgentManifest(agentPath);
+  if (!manifest) {
     return { success: false, message: `Agent manifest not found: ${agentName}` };
   }
 
   try {
-    // Load manifest
-    const manifest = YAML.parse(readFileSync(manifestPath, 'utf-8')) as AgentManifest;
-
-    // Load content (AGENT.md)
-    let agentContent = '';
-    if (existsSync(contentPath)) {
-      const rawContent = readFileSync(contentPath, 'utf-8');
-      // Strip frontmatter from AGENT.md if present (we'll use AGENT.yaml for metadata)
-      const frontmatterMatch = rawContent.match(/^---\n[\s\S]*?\n---\n?/);
-      agentContent = frontmatterMatch ? rawContent.slice(frontmatterMatch[0].length) : rawContent;
-    }
-
-    // If no AGENT.md content, use persona from AGENT.yaml
-    if (!agentContent.trim() && manifest.persona) {
-      agentContent = manifest.persona;
-    }
+    // Load content (strip frontmatter)
+    const rawContent = readFileSync(agentPath, 'utf-8');
+    const frontmatterMatch = rawContent.match(/^---\n[\s\S]*?\n---\n?/);
+    const agentContent = frontmatterMatch ? rawContent.slice(frontmatterMatch[0].length) : rawContent;
 
     // Generate format based on platform
     const installedContent = config.platform === Platform.ClaudeCode
@@ -222,7 +246,7 @@ export function installAgentFromPath(agentDir: string, agentName: string): { suc
 }
 
 /**
- * Find the path to an agent within the tools directory structure
+ * Find the path to an agent file within the tools directory structure
  */
 export function findAgentPath(agentName: string): string | null {
   if (!existsSync(BUNDLED_TOOLS_DIR)) {
@@ -234,9 +258,9 @@ export function findAgentPath(agentName: string): string | null {
     .map((dirent) => dirent.name);
 
   for (const toolName of toolDirs) {
-    const agentDir = join(BUNDLED_TOOLS_DIR, toolName, 'agents', agentName);
-    if (existsSync(agentDir) && existsSync(join(agentDir, 'AGENT.yaml'))) {
-      return agentDir;
+    const agentPath = join(BUNDLED_TOOLS_DIR, toolName, 'agents', `${agentName}.md`);
+    if (existsSync(agentPath)) {
+      return agentPath;
     }
   }
 
@@ -245,14 +269,13 @@ export function findAgentPath(agentName: string): string | null {
 
 /**
  * Install an agent from the tools directory
- * Combines AGENT.yaml metadata with AGENT.md content into a single .md file
  */
 export function installAgent(agentName: string): { success: boolean; message: string } {
-  const agentDir = findAgentPath(agentName);
-  if (!agentDir) {
+  const agentPath = findAgentPath(agentName);
+  if (!agentPath) {
     return { success: false, message: `Agent '${agentName}' not found` };
   }
-  return installAgentFromPath(agentDir, agentName);
+  return installAgentFromPath(agentPath, agentName);
 }
 
 /**

package/src/lib/config.ts

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
-import { Platform, BuiltInOutput, type DroidConfig, type LegacyDroidConfig, type SkillOverrides, type AutoUpdateConfig } from './types.js';
+import { Platform, BuiltInOutput, type DroidConfig, type LegacyDroidConfig, type SkillOverrides, type AutoUpdateConfig } from './types';
 
 const CONFIG_DIR = join(homedir(), '.droid');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');

package/src/lib/platforms.ts

@@ -1,6 +1,6 @@
 import { join } from 'path';
 import { homedir } from 'os';
-import { Platform } from './types.js';
+import { Platform } from './types';
 
 /**
  * Platform-specific paths configuration

package/src/lib/skill-config.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { saveSkillOverrides, loadConfig, loadSkillOverrides } from './config.js';
-import { ConfigOptionType, type SkillOverrides, type ConfigOption } from './types.js';
+import { saveSkillOverrides, loadConfig, loadSkillOverrides } from './config';
+import { ConfigOptionType, type SkillOverrides, type ConfigOption } from './types';
 
 /**
  * Prompt user to configure a skill after install

package/src/lib/skills.test.ts

@@ -4,14 +4,15 @@ import { join } from 'path';
 import { tmpdir } from 'os';
 import { homedir } from 'os';
 import YAML from 'yaml';
-import { Platform, SkillStatus } from './types.js';
+import { Platform, SkillStatus } from './types';
 import {
   getSkillsInstallPath,
   getCommandsInstallPath,
   getPlatformConfigPath,
   getSkillStatusDisplay,
   getBundledSkillsDir,
-} from './skills.js';
+  loadSkillManifest,
+} from './skills';
 
 /**
  * Parse YAML frontmatter from markdown content
@@ -180,58 +181,52 @@ function getAllSkillPaths(toolsDir: string): Array<{ skillName: string; skillDir
 }
 
 describe('bundled skills validation', () => {
-  it('all skills should have SKILL.md with valid frontmatter', () => {
+  it('all skills should have SKILL.md', () => {
     const toolsDir = getBundledSkillsDir();
     const skillPaths = getAllSkillPaths(toolsDir);
 
     expect(skillPaths.length).toBeGreaterThan(0);
 
-    for (const { skillName, skillDir } of skillPaths) {
+    for (const { skillDir } of skillPaths) {
       const skillMdPath = join(skillDir, 'SKILL.md');
       expect(existsSync(skillMdPath)).toBe(true);
-
-      const content = readFileSync(skillMdPath, 'utf-8');
-      const frontmatter = parseFrontmatter(content);
-
-      expect(frontmatter).not.toBeNull();
-      expect(frontmatter?.name).toBe(skillName);
-      expect(typeof frontmatter?.description).toBe('string');
     }
   });
 
-  it('all skills should have SKILL.yaml manifest', () => {
+  it('all skills should have metadata in TOOL.yaml', () => {
     const toolsDir = getBundledSkillsDir();
     const skillPaths = getAllSkillPaths(toolsDir);
 
     for (const { skillName, skillDir } of skillPaths) {
-      const yamlPath = join(skillDir, 'SKILL.yaml');
-      expect(existsSync(yamlPath)).toBe(true);
-
-      const content = readFileSync(yamlPath, 'utf-8');
-      const manifest = YAML.parse(content);
-
-      expect(manifest.name).toBe(skillName);
-      expect(typeof manifest.description).toBe('string');
-      expect(typeof manifest.version).toBe('string');
+      // Get the parent tool directory
+      const toolDir = join(skillDir, '..', '..');
+      const toolYamlPath = join(toolDir, 'TOOL.yaml');
+      expect(existsSync(toolYamlPath)).toBe(true);
+
+      const toolContent = readFileSync(toolYamlPath, 'utf-8');
+      const toolManifest = YAML.parse(toolContent);
+
+      // Find the skill in includes.skills
+      const skillInclude = toolManifest.includes?.skills?.find(
+        (s: { name: string }) => s.name === skillName
+      );
+      expect(skillInclude).toBeDefined();
+      expect(typeof toolManifest.description).toBe('string');
+      expect(typeof toolManifest.version).toBe('string');
     }
   });
 
-  it('SKILL.md frontmatter should match SKILL.yaml', () => {
+  it('loadSkillManifest should return valid manifest from TOOL.yaml', () => {
     const toolsDir = getBundledSkillsDir();
     const skillPaths = getAllSkillPaths(toolsDir);
 
-    for (const { skillDir } of skillPaths) {
-      const mdPath = join(skillDir, 'SKILL.md');
-      const yamlPath = join(skillDir, 'SKILL.yaml');
-
-      const mdContent = readFileSync(mdPath, 'utf-8');
-      const yamlContent = readFileSync(yamlPath, 'utf-8');
-
-      const frontmatter = parseFrontmatter(mdContent);
-      const manifest = YAML.parse(yamlContent);
+    for (const { skillName, skillDir } of skillPaths) {
+      const manifest = loadSkillManifest(skillDir);
 
-      expect(frontmatter?.name).toBe(manifest.name);
-      expect(frontmatter?.description).toBe(manifest.description);
+      expect(manifest).not.toBeNull();
+      expect(manifest?.name).toBe(skillName);
+      expect(typeof manifest?.description).toBe('string');
+      expect(typeof manifest?.version).toBe('string');
     }
   });
 });

package/src/lib/skills.ts

@@ -2,10 +2,11 @@ import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, rmSync
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
-import { loadConfig, saveConfig } from './config.js';
-import { Platform, SkillStatus, type SkillManifest, type InstalledSkill, getPlatformTools, setPlatformTools } from './types.js';
-import { getInstalledAgentsDir, installAgentFromPath, uninstallAgent, isAgentInstalled } from './agents.js';
-import { getSkillsPath, getCommandsPath, getConfigPath } from './platforms.js';
+import { loadConfig, saveConfig } from './config';
+import { Platform, SkillStatus, type SkillManifest, type InstalledSkill, getPlatformTools, setPlatformTools } from './types';
+import { getInstalledAgentsDir, installAgentFromPath, uninstallAgent, isAgentInstalled } from './agents';
+import { getSkillsPath, getCommandsPath, getConfigPath } from './platforms';
+import { loadToolManifest } from './tools';
 
 // Marker comments for CLAUDE.md skill registration
 const DROID_SKILLS_START = '<!-- droid-skills-start -->';
@@ -84,22 +85,57 @@ export function updatePlatformConfigSkills(platform: Platform, installedSkills:
   writeFileSync(configPath, content, 'utf-8');
 }
 
+/**
+ * Parse YAML frontmatter from SKILL.md content
+ */
+function parseSkillFrontmatter(content: string): Record<string, unknown> | null {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith('---')) {
+    return null;
+  }
+  const endMatch = trimmed.slice(3).indexOf('---');
+  if (endMatch === -1) {
+    return null;
+  }
+  const frontmatterContent = trimmed.slice(3, 3 + endMatch);
+  try {
+    return YAML.parse(frontmatterContent);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Load a skill manifest from a skill directory
+ * Reads frontmatter from SKILL.md, version from TOOL.yaml
  */
 export function loadSkillManifest(skillDir: string): SkillManifest | null {
-  const manifestPath = join(skillDir, 'SKILL.yaml');
+  const skillMdPath = join(skillDir, 'SKILL.md');
 
-  if (!existsSync(manifestPath)) {
+  // Read SKILL.md and parse frontmatter
+  if (!existsSync(skillMdPath)) {
     return null;
   }
 
-  try {
-    const content = readFileSync(manifestPath, 'utf-8');
-    return YAML.parse(content) as SkillManifest;
-  } catch {
+  const content = readFileSync(skillMdPath, 'utf-8');
+  const frontmatter = parseSkillFrontmatter(content);
+
+  if (!frontmatter || !frontmatter.name) {
     return null;
   }
+
+  // Get version and other tool-level info from TOOL.yaml
+  const toolDir = dirname(dirname(skillDir)); // skillDir is tools/{tool}/skills/{skill}, toolDir is tools/{tool}
+  const toolManifest = loadToolManifest(toolDir);
+
+  return {
+    name: frontmatter.name as string,
+    description: frontmatter.description as string || '',
+    version: toolManifest?.version || '0.0.0',
+    status: toolManifest?.status,
+    dependencies: toolManifest?.dependencies,
+    config_schema: toolManifest?.config_schema,
+  };
 }
 
 /**
@@ -120,7 +156,8 @@ export function findSkillPath(skillName: string): { toolDir: string; skillDir: s
     if (!existsSync(skillsDir)) continue;
 
     const skillDir = join(skillsDir, skillName);
-    if (existsSync(skillDir) && existsSync(join(skillDir, 'SKILL.yaml'))) {
+    // Check for SKILL.md (content file) - metadata now comes from TOOL.yaml
+    if (existsSync(skillDir) && existsSync(join(skillDir, 'SKILL.md'))) {
       return {
         toolDir: join(BUNDLED_SKILLS_DIR, toolName),
         skillDir,
@@ -385,7 +422,7 @@ export function installSkill(skillName: string): { success: boolean; message: st
     mkdirSync(skillsPath, { recursive: true });
   }
 
-  // Copy SKILL.md (the actual skill file for Claude Code / OpenCode)
+  // Copy SKILL.md (includes its own frontmatter)
   const skillMdSource = join(skillDir, 'SKILL.md');
   if (existsSync(skillMdSource)) {
     if (!existsSync(targetSkillDir)) {

package/src/lib/tools.ts

@@ -2,9 +2,9 @@ import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
-import { loadConfig } from './config.js';
-import { type ToolManifest, type ToolIncludes, getPlatformTools } from './types.js';
-import { compareSemver } from './version.js';
+import { loadConfig } from './config';
+import { type ToolManifest, type ToolIncludes, getPlatformTools } from './types';
+import { compareSemver } from './version';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const BUNDLED_TOOLS_DIR = join(__dirname, '../tools');

package/src/lib/types.test.ts

@@ -6,7 +6,7 @@ import {
   SkillStatus,
   ConfigOptionType,
   getAITag,
-} from './types.js';
+} from './types';
 
 describe('Platform enum', () => {
   it('should have correct values', () => {

package/src/lib/types.ts

@@ -127,6 +127,11 @@ export interface ToolSkillInclude {
   name: string;
   required: boolean;
   description?: string;
+  // Skill-specific metadata (injected as frontmatter on install)
+  globs?: string[];
+  alwaysApply?: boolean;
+  provides_output?: boolean;
+  examples?: SkillExample[];
 }
 
 export interface ToolIncludes {

package/src/lib/version.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test';
-import { getVersion, compareSemver } from './version.js';
+import { getVersion, compareSemver } from './version';
 
 describe('getVersion', () => {
   it('should return a version string', () => {

package/src/tools/README.md

@@ -1,55 +1,63 @@
-# Contributing Skills
+# Contributing Tools
 
-Skills are reusable AI capabilities that can be installed into Claude Code or OpenCode.
+Tools are bundles of skills, commands, and agents that can be installed into Claude Code or OpenCode.
 
 ## Directory Structure
 
-Each skill is a directory containing:
-
 ```
-skills/
-└── my-skill/
-    ├── SKILL.yaml      # Required: Manifest with metadata
-    ├── SKILL.md        # Required: Instructions for the AI
-    └── commands/       # Optional: Slash commands
-        └── my-command.md
+tools/
+└── my-tool/
+    ├── TOOL.yaml              # Required: Tool manifest
+    ├── skills/
+    │   └── my-skill/
+    │       ├── SKILL.md       # Required: Skill instructions + frontmatter
+    │       └── references/    # Optional: Additional context files
+    ├── commands/
+    │   └── my-command.md      # Command instructions + frontmatter
+    └── agents/
+        └── my-agent.md        # Agent instructions + frontmatter
 ```
 
-## SKILL.yaml (Manifest)
+## TOOL.yaml (Manifest)
+
+The tool manifest defines what's included and tool-level metadata:
 
 ```yaml
-name: my-skill                          # Must match directory name
-description: Short description          # Shown in TUI and listings
-version: 1.0.0                          # Semver
-status: beta                            # alpha | beta | stable (optional)
-dependencies: []                        # Other skills required (optional)
-provides_output: false                  # Can this skill be an output target?
-
-# Configuration schema (optional)
-config_schema:
+name: my-tool
+description: "Short description shown in TUI"
+version: 1.0.0
+status: beta                    # alpha | beta | stable
+
+includes:
+  skills:
+    - name: my-skill
+      required: true            # Must be installed with tool
+  commands:
+    - my-command                # Just the name (no extension)
+  agents:
+    - my-agent                  # Just the name (no extension)
+
+dependencies: []                # Other tools required
+
+config_schema:                  # Optional configuration
   option_name:
-    type: string                        # string | boolean
+    type: string
     description: What this option does
-    default: "default value"            # Optional default
-
-# Examples shown in TUI (optional)
-examples:
-  - title: "Example name"
-    code: |
-      // Example code block
+    default: "default value"
 ```
 
-## SKILL.md (AI Instructions)
+## Skills
 
-The SKILL.md file contains instructions for the AI. It must have YAML frontmatter:
+Skills provide context and instructions to the AI. Create `skills/{name}/SKILL.md`:
 
 ```markdown
 ---
 name: my-skill
-description: Short description (must match SKILL.yaml)
+description: "What this skill does"
 globs:
-  - "**/*"                              # File patterns this skill applies to
-alwaysApply: false                      # Always include in context?
+  - "**/*.ts"                   # File patterns this skill applies to
+alwaysApply: false              # Always include in context?
+allowed-tools: Read, Grep, Glob # Pre-authorize tools (reduces permission prompts)
 ---
 
 # My Skill
@@ -57,29 +65,50 @@ alwaysApply: false                      # Always include in context?
 Instructions for the AI on how to use this skill...
 ```
 
-## Commands (Optional)
+Skills can have a `references/` subdirectory for additional context files.
 
-Commands are slash commands the user can invoke. Each is a markdown file:
+## Commands
 
+Commands are slash commands the user can invoke. Create `commands/{name}.md`:
+
+```markdown
+---
+name: my-command
+description: "What this command does"
+---
+
+Instructions for what to do when /my-command is invoked...
 ```
-commands/
-└── do-thing.md
-```
 
-The command file is just markdown instructions. The filename becomes the command name (`/do-thing`).
+## Agents
+
+Agents are specialized AI personas. Create `agents/{name}.md`:
+
+```markdown
+---
+name: my-agent
+description: "What this agent does"
+tools:
+  - Read
+  - Grep
+  - Glob
+color: purple                   # Display colour (Claude Code only)
+---
+
+You are a specialized agent that...
+```
 
-## Testing Your Skill
+## Testing Your Tool
 
-1. Run `npm run build` to compile
-2. Run `droid` to open the TUI
-3. Navigate to Skills tab
-4. Install your skill
-5. Test in Claude Code with `/your-command` or by referencing the skill
+1. Run `bun run build` to compile
+2. Run `bun run start` to open the TUI
+3. Navigate to your tool
+4. Install the tool
+5. Test in Claude Code
 
 ## Checklist
 
-- [ ] `SKILL.yaml` has all required fields (name, description, version)
-- [ ] `SKILL.md` has valid YAML frontmatter
-- [ ] Name in frontmatter matches directory name
-- [ ] Description matches between SKILL.yaml and SKILL.md
-- [ ] Tests pass: `bun test src/lib/skills.test.ts`
+- [ ] `TOOL.yaml` has all required fields (name, description, version, includes)
+- [ ] All .md files have valid YAML frontmatter with `name` and `description`
+- [ ] Names in frontmatter match the file/directory names
+- [ ] Tests pass: `bun test`