@orderful/droid 0.17.2 → 0.19.0

package/dist/tools/project/TOOL.yaml

@@ -1,11 +1,11 @@
 name: project
 description: "Manage project context files for persistent AI memory across sessions. Load, update, or create project context before working on multi-session features."
-version: 0.1.3
+version: 0.1.5
 status: beta
 
 includes:
   skills:
-    - name: project
+    - name: droid-project
       required: true
   commands:
     - project

package/{src/tools/project/skills/project → dist/tools/project/skills/droid-project}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: project
+name: droid-project
 description: "Persistent project context for AI memory across sessions. Use when working on multi-session features, refactors, or any work that benefits from accumulated context. User prompts like 'load the project', 'update project context', 'what's the current project?'."
 globs:
   - "**/PROJECT.md"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orderful/droid",
-  "version": "0.17.2",
+  "version": "0.19.0",
   "description": "AI workflow toolkit for sharing skills, commands, and agents across the team",
   "type": "module",
   "bin": {

package/src/lib/config.ts

@@ -160,11 +160,21 @@ export function getConfigDir(): string {
   return CONFIG_DIR;
 }
 
+/**
+ * Normalize skill name for config paths.
+ * Strips 'droid-' prefix since that was added as a workaround for Claude Code bug.
+ * Config paths should stay intuitive (e.g., ~/.droid/skills/brain/ not ~/.droid/skills/droid-brain/)
+ */
+function normalizeSkillNameForConfig(skillName: string): string {
+  return skillName.replace(/^droid-/, '');
+}
+
 /**
  * Get skill-specific overrides path
  */
 export function getSkillOverridesPath(skillName: string): string {
-  return join(CONFIG_DIR, 'skills', skillName, 'overrides.yaml');
+  const normalizedName = normalizeSkillNameForConfig(skillName);
+  return join(CONFIG_DIR, 'skills', normalizedName, 'overrides.yaml');
 }
 
 /**
@@ -189,8 +199,9 @@ export function loadSkillOverrides(skillName: string): SkillOverrides {
  * Save skill-specific overrides
  */
 export function saveSkillOverrides(skillName: string, overrides: SkillOverrides): void {
+  const normalizedName = normalizeSkillNameForConfig(skillName);
   const overridesPath = getSkillOverridesPath(skillName);
-  const skillDir = join(CONFIG_DIR, 'skills', skillName);
+  const skillDir = join(CONFIG_DIR, 'skills', normalizedName);
 
   if (!existsSync(skillDir)) {
     mkdirSync(skillDir, { recursive: true });

package/src/lib/migrations.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getToolMigrations } from './migrations';
+
+describe('migrations', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `droid-migration-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('getToolMigrations', () => {
+    it('should return migrations for known tools', () => {
+      const brainMigrations = getToolMigrations('brain');
+      expect(brainMigrations.length).toBeGreaterThan(0);
+      expect(brainMigrations[0].version).toBe('0.2.3');
+    });
+
+    it('should return empty array for unknown tools', () => {
+      const migrations = getToolMigrations('unknown-tool');
+      expect(migrations).toEqual([]);
+    });
+
+    it('should have migrations for all renamed tools', () => {
+      const tools = ['brain', 'comments', 'project', 'coach'];
+      for (const tool of tools) {
+        const migrations = getToolMigrations(tool);
+        expect(migrations.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('config directory migration', () => {
+    it('should move old prefixed directory to unprefixed', () => {
+      // Setup: create old prefixed directory with config
+      const skillsDir = join(testDir, 'skills');
+      const oldDir = join(skillsDir, 'droid-brain');
+      const newDir = join(skillsDir, 'brain');
+
+      mkdirSync(oldDir, { recursive: true });
+      writeFileSync(join(oldDir, 'overrides.yaml'), 'brain_dir: /test/path\n');
+
+      // Get the migration and run it
+      const migrations = getToolMigrations('brain');
+      const migration = migrations[0];
+      migration.up(testDir);
+
+      // Verify
+      expect(existsSync(oldDir)).toBe(false);
+      expect(existsSync(newDir)).toBe(true);
+      expect(readFileSync(join(newDir, 'overrides.yaml'), 'utf-8')).toBe('brain_dir: /test/path\n');
+    });
+
+    it('should be idempotent - no error if old directory already moved', () => {
+      // Setup: only new directory exists (already migrated)
+      const skillsDir = join(testDir, 'skills');
+      const newDir = join(skillsDir, 'brain');
+
+      mkdirSync(newDir, { recursive: true });
+      writeFileSync(join(newDir, 'overrides.yaml'), 'brain_dir: /test/path\n');
+
+      // Get the migration and run it - should not throw
+      const migrations = getToolMigrations('brain');
+      const migration = migrations[0];
+
+      expect(() => migration.up(testDir)).not.toThrow();
+      expect(existsSync(newDir)).toBe(true);
+    });
+
+    it('should handle collision by removing old directory', () => {
+      // Setup: both old and new directories exist
+      const skillsDir = join(testDir, 'skills');
+      const oldDir = join(skillsDir, 'droid-brain');
+      const newDir = join(skillsDir, 'brain');
+
+      mkdirSync(oldDir, { recursive: true });
+      mkdirSync(newDir, { recursive: true });
+      writeFileSync(join(oldDir, 'overrides.yaml'), 'old: true\n');
+      writeFileSync(join(newDir, 'overrides.yaml'), 'new: true\n');
+
+      // Run migration
+      const migrations = getToolMigrations('brain');
+      const migration = migrations[0];
+      migration.up(testDir);
+
+      // Old should be removed, new should be preserved
+      expect(existsSync(oldDir)).toBe(false);
+      expect(existsSync(newDir)).toBe(true);
+      expect(readFileSync(join(newDir, 'overrides.yaml'), 'utf-8')).toBe('new: true\n');
+    });
+
+    it('should do nothing if neither directory exists', () => {
+      // Setup: empty skills directory
+      const skillsDir = join(testDir, 'skills');
+      mkdirSync(skillsDir, { recursive: true });
+
+      // Run migration - should not throw
+      const migrations = getToolMigrations('brain');
+      const migration = migrations[0];
+
+      expect(() => migration.up(testDir)).not.toThrow();
+    });
+
+    it('should create parent directory if needed', () => {
+      // Setup: old directory exists but skills/ parent doesn't exist for new
+      const oldDir = join(testDir, 'skills', 'droid-brain');
+      mkdirSync(oldDir, { recursive: true });
+      writeFileSync(join(oldDir, 'overrides.yaml'), 'test: true\n');
+
+      // Run migration
+      const migrations = getToolMigrations('brain');
+      const migration = migrations[0];
+      migration.up(testDir);
+
+      // Should have moved successfully
+      const newDir = join(testDir, 'skills', 'brain');
+      expect(existsSync(newDir)).toBe(true);
+      expect(existsSync(oldDir)).toBe(false);
+    });
+  });
+
+  describe('migration versions', () => {
+    it('brain migration should be version 0.2.3', () => {
+      const migrations = getToolMigrations('brain');
+      expect(migrations[0].version).toBe('0.2.3');
+    });
+
+    it('comments migration should be version 0.2.6', () => {
+      const migrations = getToolMigrations('comments');
+      expect(migrations[0].version).toBe('0.2.6');
+    });
+
+    it('project migration should be version 0.1.5', () => {
+      const migrations = getToolMigrations('project');
+      expect(migrations[0].version).toBe('0.1.5');
+    });
+
+    it('coach migration should be version 0.1.3', () => {
+      const migrations = getToolMigrations('coach');
+      expect(migrations[0].version).toBe('0.1.3');
+    });
+  });
+
+  describe('migration descriptions', () => {
+    it('should have descriptive migration descriptions', () => {
+      const tools = ['brain', 'comments', 'project', 'coach'];
+      for (const tool of tools) {
+        const migrations = getToolMigrations(tool);
+        expect(migrations[0].description).toContain('config');
+        expect(migrations[0].description).toContain('unprefixed');
+      }
+    });
+  });
+});

package/src/lib/migrations.ts

@@ -0,0 +1,182 @@
+import { existsSync, appendFileSync, mkdirSync, renameSync, rmSync } from 'fs';
+import { join, dirname } from 'path';
+import { loadConfig, saveConfig, getConfigDir } from './config';
+import { type Migration } from './types';
+import { compareSemver } from './version';
+
+const MIGRATIONS_LOG_FILE = '.migrations.log';
+
+/**
+ * Get the path to the migrations log file
+ */
+function getMigrationsLogPath(): string {
+  return join(getConfigDir(), MIGRATIONS_LOG_FILE);
+}
+
+/**
+ * Log a migration event to the hidden log file
+ */
+function logMigration(
+  toolName: string,
+  fromVersion: string,
+  toVersion: string,
+  status: 'OK' | 'FAILED',
+  error?: string
+): void {
+  const timestamp = new Date().toISOString();
+  const logEntry = error
+    ? `${timestamp} ${toolName} ${fromVersion} → ${toVersion} ${status}: ${error}\n`
+    : `${timestamp} ${toolName} ${fromVersion} → ${toVersion} ${status}\n`;
+
+  const logPath = getMigrationsLogPath();
+  const logDir = dirname(logPath);
+
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+
+  appendFileSync(logPath, logEntry);
+}
+
+// ============================================================================
+// Tool Migrations Registry
+// Define migrations here, keyed by tool name
+// ============================================================================
+
+/**
+ * Migration: Move droid-prefixed config directories to unprefixed names
+ * e.g., ~/.droid/skills/droid-brain/ → ~/.droid/skills/brain/
+ *
+ * This fixes a bug where config was saved to prefixed paths but SKILL.md
+ * tells Claude to read from unprefixed paths.
+ */
+function createConfigDirMigration(skillName: string, version: string): Migration {
+  const unprefixedName = skillName.replace(/^droid-/, '');
+  return {
+    version,
+    description: `Move ${skillName} config to unprefixed location`,
+    up: (configDir: string) => {
+      const oldDir = join(configDir, 'skills', skillName);
+      const newDir = join(configDir, 'skills', unprefixedName);
+
+      // Only migrate if old exists and new doesn't
+      if (existsSync(oldDir) && !existsSync(newDir)) {
+        // Ensure parent directory exists
+        const parentDir = dirname(newDir);
+        if (!existsSync(parentDir)) {
+          mkdirSync(parentDir, { recursive: true });
+        }
+        renameSync(oldDir, newDir);
+      } else if (existsSync(oldDir) && existsSync(newDir)) {
+        // Both exist - remove the old one (new takes precedence)
+        rmSync(oldDir, { recursive: true });
+      }
+    },
+  };
+}
+
+/**
+ * Registry of all tool migrations
+ * Key: tool name (e.g., "brain", "comments")
+ * Value: array of migrations sorted by version
+ *
+ * Migration versions are set to the next version after each tool's current version:
+ * - brain: 0.2.2 → 0.2.3
+ * - comments: 0.2.5 → 0.2.6
+ * - project: 0.1.4 → 0.1.5
+ * - coach: 0.1.2 → 0.1.3
+ */
+const TOOL_MIGRATIONS: Record<string, Migration[]> = {
+  brain: [createConfigDirMigration('droid-brain', '0.2.3')],
+  comments: [createConfigDirMigration('droid-comments', '0.2.6')],
+  project: [createConfigDirMigration('droid-project', '0.1.5')],
+  coach: [createConfigDirMigration('droid-coach', '0.1.3')],
+};
+
+/**
+ * Get migrations for a tool
+ */
+export function getToolMigrations(toolName: string): Migration[] {
+  return TOOL_MIGRATIONS[toolName] ?? [];
+}
+
+/**
+ * Get the last migrated version for a tool
+ */
+export function getLastMigratedVersion(toolName: string): string {
+  const config = loadConfig();
+  return config.migrations?.[toolName] ?? '0.0.0';
+}
+
+/**
+ * Update the last migrated version for a tool
+ */
+export function setLastMigratedVersion(toolName: string, version: string): void {
+  const config = loadConfig();
+  if (!config.migrations) {
+    config.migrations = {};
+  }
+  config.migrations[toolName] = version;
+  saveConfig(config);
+}
+
+/**
+ * Run migrations for a tool between two versions
+ * Returns true if all migrations succeeded, false otherwise
+ */
+export function runMigrations(
+  toolName: string,
+  fromVersion: string,
+  toVersion: string
+): { success: boolean; error?: string } {
+  const migrations = getToolMigrations(toolName);
+
+  // Filter migrations that need to run (version > fromVersion && version <= toVersion)
+  const pendingMigrations = migrations.filter((m) => {
+    const afterFrom = compareSemver(m.version, fromVersion) > 0;
+    const beforeOrAtTo = compareSemver(m.version, toVersion) <= 0;
+    return afterFrom && beforeOrAtTo;
+  });
+
+  if (pendingMigrations.length === 0) {
+    // No migrations to run, but still update the version marker
+    setLastMigratedVersion(toolName, toVersion);
+    return { success: true };
+  }
+
+  const configDir = getConfigDir();
+
+  for (const migration of pendingMigrations) {
+    try {
+      migration.up(configDir);
+      logMigration(toolName, fromVersion, migration.version, 'OK');
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logMigration(toolName, fromVersion, migration.version, 'FAILED', errorMessage);
+      // Don't update version marker on failure - will retry next time
+      return { success: false, error: `Migration ${migration.version} failed: ${errorMessage}` };
+    }
+  }
+
+  // All migrations succeeded, update version marker
+  setLastMigratedVersion(toolName, toVersion);
+  return { success: true };
+}
+
+/**
+ * Run migrations for a tool after install/update
+ * Call this after installSkill() completes
+ */
+export function runToolMigrations(
+  toolName: string,
+  installedVersion: string
+): { success: boolean; error?: string } {
+  const lastMigrated = getLastMigratedVersion(toolName);
+
+  // Only run if the installed version is newer than last migrated
+  if (compareSemver(installedVersion, lastMigrated) <= 0) {
+    return { success: true };
+  }
+
+  return runMigrations(toolName, lastMigrated, installedVersion);
+}

package/src/lib/skill-config.ts

@@ -86,7 +86,9 @@ export async function promptForSkillConfig(
 
   if (Object.keys(overrides).length > 0) {
     saveSkillOverrides(skillName, overrides);
-    console.log(chalk.green(`\n✓ Configuration saved to ~/.droid/skills/${skillName}/overrides.yaml`));
+    // Strip droid- prefix for display since that's where the file actually goes
+    const displayName = skillName.replace(/^droid-/, '');
+    console.log(chalk.green(`\n✓ Configuration saved to ~/.droid/skills/${displayName}/overrides.yaml`));
   } else {
     console.log(chalk.gray('\nNo custom configuration set (using defaults).'));
   }

package/src/lib/skills.ts

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, rmSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
 import { loadConfig, saveConfig } from './config';
@@ -7,6 +7,7 @@ import { Platform, SkillStatus, type SkillManifest, type InstalledSkill, getPlat
 import { getInstalledAgentsDir, installAgentFromPath, uninstallAgent, isAgentInstalled } from './agents';
 import { getSkillsPath, getCommandsPath, getConfigPath } from './platforms';
 import { loadToolManifest } from './tools';
+import { runToolMigrations } from './migrations';
 
 // Marker comments for CLAUDE.md skill registration
 const DROID_SKILLS_START = '<!-- droid-skills-start -->';
@@ -378,6 +379,53 @@ export function installSkill(skillName: string): { success: boolean; message: st
   const commandsPath = getCommandsInstallPath(config.platform);
   const tools = getPlatformTools(config);
 
+  // Clean up old skill directory if this is a renamed skill (v0.18.0 workaround for Claude Code bug)
+  // Renamed skills have 'droid-' prefix, so check for old directory without prefix
+  // Bug: https://github.com/anthropics/claude-code/issues/14945
+  //
+  // TO REVERSE WHEN BUG IS FIXED:
+  // 1. Rename directories: droid-comments/ → comments/, droid-brain/ → brain/, etc.
+  // 2. Update TOOL.yaml manifests back to original skill names
+  // 3. Update SKILL.md frontmatter back to original names
+  // 4. Replace this cleanup logic with inverse:
+  //    const renamedSkills = ['comments', 'brain', 'project', 'coach', 'code-review', 'brain-obsidian'];
+  //    if (renamedSkills.includes(skillName)) {
+  //      const droidPrefixedName = `droid-${skillName}`;
+  //      const droidPrefixedDir = join(skillsPath, droidPrefixedName);
+  //      if (existsSync(droidPrefixedDir)) {
+  //        rmSync(droidPrefixedDir, { recursive: true });
+  //      }
+  //      if (tools[droidPrefixedName]) {
+  //        delete tools[droidPrefixedName];
+  //      }
+  //    }
+  // 5. Bump tool versions and create changeset
+  // Migration logic: Handle skills renamed from {name} to droid-{name} (v0.18.0 workaround)
+  // This handles both fresh installs and updates where old directory/config entries exist
+  if (skillName.startsWith('droid-')) {
+    const oldSkillName = skillName.replace(/^droid-/, '');
+    const oldSkillDir = join(skillsPath, oldSkillName);
+
+    // Remove or migrate old skill directory
+    if (existsSync(oldSkillDir)) {
+      try {
+        rmSync(oldSkillDir, { recursive: true });
+      } catch (error) {
+        // Non-fatal: Log warning but continue installation
+        console.warn(`Warning: Could not remove old skill directory ${oldSkillDir}: ${error}`);
+      }
+    }
+
+    // Migrate old config entry if it exists
+    // This allows tools to show as "update available" rather than "not installed"
+    if (tools[oldSkillName]) {
+      delete tools[oldSkillName];
+      // Save immediately to ensure cleanup is persisted (matches pattern in tools.ts)
+      setPlatformTools(config, tools);
+      saveConfig(config);
+    }
+  }
+
   // Commands and agents are at the tool level, not skill level
   const commandsSource = join(toolDir, 'commands');
   const agentsSource = join(toolDir, 'agents');
@@ -495,6 +543,14 @@ export function installSkill(skillName: string): { success: boolean; message: st
   const installedSkillNames = Object.keys(updatedTools);
   updatePlatformConfigSkills(config.platform, installedSkillNames);
 
+  // Run tool migrations (keyed by tool name, not skill name)
+  const toolName = basename(toolDir);
+  const migrationResult = runToolMigrations(toolName, manifest.version);
+  if (!migrationResult.success) {
+    // Log warning but don't fail the install - migration will retry next time
+    console.warn(`Warning: Migration failed for ${toolName}: ${migrationResult.error}`);
+  }
+
   return { success: true, message: `Installed ${skillName} v${manifest.version}` };
 }
 

package/src/lib/tools.ts

@@ -2,8 +2,8 @@ import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import YAML from 'yaml';
-import { loadConfig } from './config';
-import { type ToolManifest, type ToolIncludes, getPlatformTools } from './types';
+import { loadConfig, saveConfig } from './config';
+import { type ToolManifest, type ToolIncludes, getPlatformTools, setPlatformTools } from './types';
 import { compareSemver } from './version';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -108,6 +108,20 @@ export function getInstalledToolVersion(toolName: string): string | null {
     if (installedTools[skillName]) {
       return installedTools[skillName].version;
     }
+
+    // Migration fallback (v0.18.0): Check for old skill name without droid- prefix
+    // This allows tools to show as "update available" rather than "not installed"
+    if (skillName.startsWith('droid-')) {
+      const oldSkillName = skillName.replace(/^droid-/, '');
+      if (installedTools[oldSkillName]) {
+        const version = installedTools[oldSkillName].version;
+        // Clean up stale config entry now that we've detected it
+        delete installedTools[oldSkillName];
+        setPlatformTools(config, installedTools);
+        saveConfig(config);
+        return version;
+      }
+    }
   }
 
   return null;

package/src/lib/types.ts

@@ -54,6 +54,7 @@ export interface DroidConfig {
   git_username: string;
   platforms: Record<string, PlatformConfig>;
   auto_update?: AutoUpdateConfig;
+  migrations?: Record<string, string>; // tool name -> last migrated version
 }
 
 // Legacy config structure for migration
@@ -120,6 +121,16 @@ export interface SkillOverrides {
   [key: string]: string | boolean | number;
 }
 
+/**
+ * Tool migration function
+ * Should be idempotent - safe to run multiple times
+ */
+export interface Migration {
+  version: string;
+  description: string;
+  up: (configDir: string) => Promise<void> | void;
+}
+
 /**
  * Tool manifest structure (TOOL.yaml)
  */

package/src/tools/brain/TOOL.yaml

@@ -1,13 +1,13 @@
 name: brain
 description: "Your scratchpad (or brain) - a collaborative space for planning and research. Create docs with /brain plan, /brain research, or /brain review. Use @mentions for async discussion. Docs persist across sessions."
-version: 0.2.1
+version: 0.2.3
 status: beta
 
 includes:
   skills:
-    - name: brain
+    - name: droid-brain
       required: true
-    - name: brain-obsidian
+    - name: droid-brain-obsidian
       required: false
       description: "Obsidian vault integration with YAML frontmatter and wikilinks"
   commands:

package/{dist/tools/brain/skills/brain → src/tools/brain/skills/droid-brain}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: brain
+name: droid-brain
 description: "Collaborative scratchpad for planning and research. Use when planning a feature, exploring a problem, or capturing thinking that should persist across sessions. User prompts like 'let's think through', 'open a scratchpad', 'plan this out', 'use our brain'."
 globs:
   - "**/brain/**/*.md"

package/src/tools/brain/skills/{brain-obsidian → droid-brain-obsidian}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: brain-obsidian
+name: droid-brain-obsidian
 description: "Obsidian extension for brain skill with YAML frontmatter, wikilinks, and PARA folder organization. Use when your brain docs live in an Obsidian vault."
 globs:
   - "**/brain/**/*.md"

package/src/tools/coach/TOOL.yaml

@@ -1,11 +1,11 @@
 name: coach
 description: "Learning-mode AI assistance - AI as coach, not crutch. Use /coach plan for co-authored planning, /coach scaffold for structure with hints, /coach review for Socratic questions."
-version: 0.1.1
+version: 0.1.3
 status: beta
 
 includes:
   skills:
-    - name: coach
+    - name: droid-coach
       required: true
   commands:
     - coach

package/src/tools/coach/skills/{coach → droid-coach}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: coach
+name: droid-coach
 description: "Learning-mode AI assistance - scaffolds don't implement, questions don't fix. Use when learning a new codebase, wanting to understand deeply, or building skills to retain. User prompts like 'coach me on', 'help me think through', 'I want to learn how to', 'don't just give me the answer'."
 alwaysApply: false
 allowed-tools: Read, Grep, Glob

package/src/tools/code-review/TOOL.yaml

@@ -1,11 +1,11 @@
 name: code-review
 description: "Comprehensive code review using specialized agents. Reviews PRs, staged changes, branches, or specific files with confidence scoring."
-version: 0.1.1
+version: 0.1.2
 status: alpha
 
 includes:
   skills:
-    - name: code-review
+    - name: droid-code-review
       required: true
   commands:
     - code-review

package/src/tools/code-review/skills/{code-review → droid-code-review}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: code-review
+name: droid-code-review
 description: "Comprehensive code review using specialized agents. Use when reviewing PRs, checking staged changes, or analysing code quality. User prompts like 'review this PR', 'check my changes', 'review before I commit'."
 globs:
   - "**/*"

package/src/tools/comments/TOOL.yaml

@@ -1,11 +1,11 @@
 name: comments
 description: "Enable inline conversations using @droid/@user markers. Tag @droid to ask the AI, AI responds with @{your-name}. Use /comments check to address markers, /comments cleanup to remove resolved threads. Ideal for code review notes and async collaboration."
-version: 0.2.4
+version: 0.2.6
 status: beta
 
 includes:
   skills:
-    - name: comments
+    - name: droid-comments
       required: true
   commands:
     - comments

package/src/tools/comments/skills/{comments → droid-comments}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: comments
+name: droid-comments
 description: "Inline conversations using @droid/@user markers in any file. Use when leaving async questions in code or having discussion that should stay near the code. User prompts like 'check for comments', 'address the @droid markers', 'clean up resolved comments'."
 globs:
   - "**/*"