@orderful/droid 0.37.0 → 0.38.0

package/src/commands/update.ts

@@ -1,7 +1,8 @@
 import chalk from 'chalk';
-import { execSync } from 'child_process';
+import { execSync, spawnSync } from 'child_process';
 import { getVersion } from '../lib/version';
 import { updateAllSkills } from '../lib/skills';
+import { getAutoUpdateConfig } from '../lib/config';
 
 interface UpdateOptions {
   tools?: boolean;
@@ -83,6 +84,25 @@ export async function updateCommand(
     execSync('npm install -g @orderful/droid@latest', { stdio: 'inherit' });
 
     console.log(chalk.green(`\n✓ Updated to v${latestVersion}`));
+
+    // Spawn NEW binary to sync tools (has new bundled manifests)
+    // Only if auto-update tools is enabled
+    const autoUpdateConfig = getAutoUpdateConfig();
+    if (autoUpdateConfig.tools) {
+      console.log(chalk.bold('\n🤖 Syncing tools...\n'));
+      const toolResult = spawnSync('droid', ['update', '--tools'], {
+        stdio: 'inherit',
+        timeout: 60000, // 60s timeout for tool sync
+      });
+
+      if (toolResult.error || toolResult.status !== 0) {
+        console.log(
+          chalk.yellow(
+            'Tool sync incomplete - run `droid update --tools` to retry',
+          ),
+        );
+      }
+    }
   } catch {
     // Package might not be published yet
     console.log(chalk.yellow('\n⚠ Could not check for updates'));

package/src/lib/agents.ts

@@ -12,8 +12,9 @@ const BUNDLED_TOOLS_DIR = join(__dirname, '../tools');
 
 /**
  * Get the installation path for agents based on platform
+ * Returns null for platforms that don't support agents (e.g., OpenAI Codex)
  */
-export function getAgentsInstallPath(platform: Platform): string {
+export function getAgentsInstallPath(platform: Platform): string | null {
   return getAgentsPath(platform);
 }
 
@@ -140,8 +141,9 @@ export function getAgentStatusDisplay(status?: string): string {
 
 /**
  * Get installed agents directory for the configured platform
+ * Returns null if platform doesn't support agents
  */
-export function getInstalledAgentsDir(): string {
+export function getInstalledAgentsDir(): string | null {
   const config = loadConfig();
   return getAgentsInstallPath(config.platform);
 }
@@ -152,6 +154,7 @@ export function getInstalledAgentsDir(): string {
 export function isAgentInstalled(agentName: string): boolean {
   const config = loadConfig();
   const agentsDir = getAgentsInstallPath(config.platform);
+  if (!agentsDir) return false; // Platform doesn't support agents
   const agentPath = join(agentsDir, `${agentName}.md`);
   return existsSync(agentPath);
 }
@@ -235,6 +238,9 @@ export function installAgentFromPath(
 
     // Ensure agents directory exists
     const agentsDir = getAgentsInstallPath(targetPlatform);
+    if (!agentsDir) {
+      return { success: false, message: `Platform ${targetPlatform} does not support agents` };
+    }
     if (!existsSync(agentsDir)) {
       mkdirSync(agentsDir, { recursive: true });
     }
@@ -300,6 +306,11 @@ export function uninstallAgent(
   const config = loadConfig();
   const targetPlatform = platform ?? config.platform;
   const agentsDir = getAgentsInstallPath(targetPlatform);
+
+  if (!agentsDir) {
+    return { success: true, message: `Platform ${targetPlatform} does not support agents` };
+  }
+
   const agentPath = join(agentsDir, `${agentName}.md`);
 
   if (!existsSync(agentPath)) {

package/src/lib/migrations.ts

@@ -305,24 +305,26 @@ function createClaudeCodeCommandCleanupMigration(version: string): Migration {
       // Clean up Claude Code commands directory regardless of current platform
       // Users may have switched platforms, leaving orphaned commands
       const commandsPath = getCommandsPath(Platform.ClaudeCode);
-      if (!existsSync(commandsPath)) {
+      // ClaudeCode always has a commands path, but check for null to satisfy TypeScript
+      if (!commandsPath || !existsSync(commandsPath)) {
         return;
       }
 
-      // Get all bundled tools to check which commands are aliases
+      // Get all bundled tools to determine which commands droid manages
       const bundledTools = getBundledTools();
-      const aliasCommands = new Set<string>();
+      const deletableDroidCommands = new Set<string>();
 
-      // Collect all alias command names across all tools
+      // Collect non-alias commands that droid manages (safe to delete)
       for (const tool of bundledTools) {
         for (const cmd of tool.includes.commands) {
-          if (typeof cmd === 'object' && cmd.is_alias) {
-            aliasCommands.add(cmd.name);
+          if (!cmd.is_alias) {
+            deletableDroidCommands.add(cmd.name);
           }
         }
       }
 
-      // Check each command file and remove non-aliases
+      // Check each command file and remove only droid's non-alias commands
+      // User-created commands (not in deletableDroidCommands) are preserved
       const commandFiles = readdirSync(commandsPath, { withFileTypes: true })
         .filter((dirent) => dirent.isFile() && dirent.name.endsWith('.md'))
         .map((dirent) => dirent.name);
@@ -330,8 +332,7 @@ function createClaudeCodeCommandCleanupMigration(version: string): Migration {
       for (const file of commandFiles) {
         const commandName = file.replace('.md', '');
 
-        // Keep aliases, remove everything else
-        if (!aliasCommands.has(commandName)) {
+        if (deletableDroidCommands.has(commandName)) {
           const commandFilePath = join(commandsPath, file);
           try {
             rmSync(commandFilePath);
@@ -491,6 +492,76 @@ function copyDirRecursive(src: string, dest: string): void {
   }
 }
 
+/**
+ * Migration: Clean up droid-managed skills from OpenCode's platform-specific directory
+ *
+ * OpenCode checks ~/.config/opencode/skill/ before ~/.claude/skills/, so old skills
+ * there shadow the unified location. This migration removes ONLY droid-managed skills
+ * from OpenCode's directory, preserving user-authored skills.
+ *
+ * Safety: Only deletes skills that are bundled with droid. User-created skills are preserved.
+ */
+function createOpenCodeSkillsCleanupMigration(version: string): Migration {
+  return {
+    version,
+    description: 'Remove droid-managed skills from OpenCode platform-specific directory',
+    up: () => {
+      const oldOpenCodeSkillsPath = join(
+        homedir(),
+        '.config',
+        'opencode',
+        'skill',
+      );
+      const unifiedSkillsPath = join(homedir(), '.claude', 'skills');
+
+      // Skip if OpenCode skills directory doesn't exist
+      if (!existsSync(oldOpenCodeSkillsPath)) {
+        return;
+      }
+
+      // Get all bundled tools to determine which skills droid manages
+      const bundledTools = getBundledTools();
+      const droidManagedSkills = new Set<string>();
+
+      // Collect skill names that droid manages (safe to delete)
+      for (const tool of bundledTools) {
+        for (const skill of tool.includes.skills) {
+          droidManagedSkills.add(skill.name);
+        }
+      }
+
+      // Get all skill directories in OpenCode's location
+      const skillDirs = readdirSync(oldOpenCodeSkillsPath, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+
+      for (const skillName of skillDirs) {
+        // SAFETY: Only delete if this is a droid-managed skill
+        if (!droidManagedSkills.has(skillName)) {
+          continue; // Preserve user-authored skills
+        }
+
+        // Only delete if unified version exists (unified is source of truth)
+        const unifiedPath = join(unifiedSkillsPath, skillName);
+        if (!existsSync(unifiedPath)) {
+          continue; // Keep OpenCode version if no unified version exists
+        }
+
+        // Delete the OpenCode-specific copy (unified version will be used)
+        const oldPath = join(oldOpenCodeSkillsPath, skillName);
+        try {
+          rmSync(oldPath, { recursive: true });
+        } catch (error) {
+          // Non-fatal: Log warning but continue with other skills
+          console.warn(
+            `Warning: Could not remove OpenCode skill ${skillName}: ${error}`,
+          );
+        }
+      }
+    },
+  };
+}
+
 /**
  * Registry of package-level migrations
  * These run when the @orderful/droid npm package updates
@@ -506,6 +577,7 @@ const PACKAGE_MIGRATIONS: Migration[] = [
   createClaudeCodeCommandCleanupMigration('0.28.1'),
   createOpenCodePluginCleanupMigration('0.29.2'),
   createUnifiedSkillsPathMigration('0.30.0'),
+  createOpenCodeSkillsCleanupMigration('0.37.1'),
 ];
 
 /**

package/src/lib/platform.codex.ts

@@ -0,0 +1,131 @@
+/**
+ * OpenAI Codex platform-specific logic
+ *
+ * Codex reads skills from ~/.codex/skills/ but droid installs to ~/.claude/skills/ (unified path).
+ * We create symlinks from Codex's location to the unified path.
+ *
+ * Key differences from other platforms:
+ * - Skills only (no commands or agents)
+ * - Uses symlinks instead of copying files
+ * - Must preserve user's own Codex skills (not managed by droid)
+ */
+
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  symlinkSync,
+  lstatSync,
+  readdirSync,
+  readlinkSync,
+} from 'fs';
+
+/**
+ * Unified skills path - where droid installs skills
+ */
+const UNIFIED_SKILLS_PATH = join(homedir(), '.claude', 'skills');
+
+/**
+ * Codex skills path - where Codex reads skills from
+ */
+export const CODEX_SKILLS_PATH = join(homedir(), '.codex', 'skills');
+
+/**
+ * Create a symlink for a skill in the Codex skills directory
+ * Symlinks from ~/.codex/skills/{name} → ~/.claude/skills/{name}
+ *
+ * Safety guarantees:
+ * - Only creates symlinks for skills that exist in unified path
+ * - Never deletes real directories (only replaces existing symlinks)
+ * - Skips if symlink already points to correct location
+ */
+export function createCodexSymlink(skillName: string): void {
+  const source = join(UNIFIED_SKILLS_PATH, skillName);
+  const target = join(CODEX_SKILLS_PATH, skillName);
+
+  // Ensure source exists
+  if (!existsSync(source)) {
+    console.warn(`Warning: Cannot create Codex symlink - source skill not found: ${source}`);
+    return;
+  }
+
+  // Ensure ~/.codex/skills/ directory exists
+  if (!existsSync(dirname(target))) {
+    mkdirSync(dirname(target), { recursive: true });
+  }
+
+  // Only touch symlinks we manage (don't delete user's real directories)
+  if (existsSync(target)) {
+    try {
+      const stat = lstatSync(target);
+      if (stat.isSymbolicLink()) {
+        // Check if it already points to the correct location
+        const currentTarget = readlinkSync(target);
+        if (currentTarget === source) {
+          return; // Already correct, nothing to do
+        }
+        rmSync(target); // Wrong target, replace it
+      } else {
+        // Real file or directory - don't touch it
+        console.warn(`Warning: ${target} exists and is not a symlink - skipping to preserve user content`);
+        return;
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not check ${target}: ${error}`);
+      return;
+    }
+  }
+
+  // Create symlink
+  try {
+    symlinkSync(source, target);
+  } catch (error) {
+    console.warn(`Warning: Could not create Codex symlink ${target} → ${source}: ${error}`);
+  }
+}
+
+/**
+ * Remove a symlink for a skill from the Codex skills directory
+ * Only removes if it's a symlink (preserves user's real directories)
+ */
+export function removeCodexSymlink(skillName: string): void {
+  const target = join(CODEX_SKILLS_PATH, skillName);
+
+  if (!existsSync(target)) {
+    return; // Nothing to remove
+  }
+
+  try {
+    const stat = lstatSync(target);
+    if (stat.isSymbolicLink()) {
+      rmSync(target);
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not remove Codex symlink ${target}: ${error}`);
+  }
+}
+
+/**
+ * Remove all droid-managed Codex symlinks (when Codex is removed or ignored)
+ * Only removes symlinks, preserves user's real directories and .system folder
+ */
+export function removeAllCodexSymlinks(): void {
+  if (!existsSync(CODEX_SKILLS_PATH)) {
+    return; // Nothing to clean up
+  }
+
+  const entries = readdirSync(CODEX_SKILLS_PATH, { withFileTypes: true });
+  for (const entry of entries) {
+    // Only remove symlinks, not the .system directory or other files
+    const entryPath = join(CODEX_SKILLS_PATH, entry.name);
+    try {
+      if (lstatSync(entryPath).isSymbolicLink()) {
+        rmSync(entryPath);
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not remove Codex symlink ${entryPath}: ${error}`);
+    }
+  }
+}

package/src/lib/platforms.ts

@@ -4,9 +4,20 @@ import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { Platform, type DroidConfig } from './types';
 
+// Re-export Codex-specific functions from platform.codex.ts
+export {
+  CODEX_SKILLS_PATH,
+  createCodexSymlink,
+  removeCodexSymlink,
+  removeAllCodexSymlinks,
+} from './platform.codex';
+
+import { createCodexSymlink } from './platform.codex';
+
 /**
  * Unified skills path - all platforms read from ~/.claude/skills/
  * This is the Agent Skills standard location supported by Claude Code, OpenCode, and Cursor.
+ * OpenAI Codex reads from ~/.codex/skills/, so we create symlinks there (see platform.codex.ts).
  */
 const UNIFIED_SKILLS_PATH = join(homedir(), '.claude', 'skills');
 
@@ -16,8 +27,17 @@ const UNIFIED_SKILLS_PATH = join(homedir(), '.claude', 'skills');
  *
  * Note: Skills are unified to ~/.claude/skills/ (all platforms read this location).
  * Commands and agents remain platform-specific as there's no cross-platform compatibility.
+ * OpenAI Codex only supports skills (via symlinks) - no commands, agents, or config integration.
  */
-export const PLATFORM_PATHS = {
+export const PLATFORM_PATHS: Record<
+  Platform,
+  {
+    skills: string;
+    commands: string | null;
+    agents: string | null;
+    config: string | null;
+  }
+> = {
   [Platform.ClaudeCode]: {
     skills: UNIFIED_SKILLS_PATH,
     commands: join(homedir(), '.claude', 'commands'),
@@ -38,9 +58,16 @@ export const PLATFORM_PATHS = {
     agents: join(homedir(), '.cursor', 'agents'),
     config: join(homedir(), '.cursor', 'rules'),
   },
-} as const;
+  [Platform.OpenAICodex]: {
+    // Codex reads from ~/.codex/skills/ but we install to unified path and symlink
+    skills: UNIFIED_SKILLS_PATH,
+    commands: null, // Not supported - Codex has built-in commands only
+    agents: null, // Not supported - Codex is single-agent
+    config: null, // No config file integration
+  },
+};
 
-export type PlatformPaths = typeof PLATFORM_PATHS[Platform];
+export type PlatformPaths = (typeof PLATFORM_PATHS)[Platform];
 
 /**
  * Get all paths for a platform
@@ -58,25 +85,42 @@ export function getSkillsPath(platform: Platform): string {
 
 /**
  * Get commands install path for a platform
+ * Returns null for platforms that don't support custom commands (e.g., OpenAI Codex)
  */
-export function getCommandsPath(platform: Platform): string {
+export function getCommandsPath(platform: Platform): string | null {
   return PLATFORM_PATHS[platform].commands;
 }
 
 /**
  * Get agents install path for a platform
+ * Returns null for platforms that don't support custom agents (e.g., OpenAI Codex)
  */
-export function getAgentsPath(platform: Platform): string {
+export function getAgentsPath(platform: Platform): string | null {
   return PLATFORM_PATHS[platform].agents;
 }
 
 /**
  * Get platform config file path (CLAUDE.md or AGENTS.md)
+ * Returns null for platforms without config file integration (e.g., OpenAI Codex)
  */
-export function getConfigPath(platform: Platform): string {
+export function getConfigPath(platform: Platform): string | null {
   return PLATFORM_PATHS[platform].config;
 }
 
+/**
+ * Check if a platform supports custom commands
+ */
+export function platformSupportsCommands(platform: Platform): boolean {
+  return PLATFORM_PATHS[platform].commands !== null;
+}
+
+/**
+ * Check if a platform supports custom agents
+ */
+export function platformSupportsAgents(platform: Platform): boolean {
+  return PLATFORM_PATHS[platform].agents !== null;
+}
+
 /**
  * Detect ALL installed platforms
  * Returns array of all platforms that are installed on the system
@@ -106,6 +150,12 @@ export function detectAllPlatforms(): Platform[] {
     // OpenCode not found
   }
 
+  // OpenAI Codex: check if .codex directory exists
+  const codexDir = join(homedir(), '.codex');
+  if (existsSync(codexDir)) {
+    detected.push(Platform.OpenAICodex);
+  }
+
   return detected;
 }
 
@@ -117,3 +167,74 @@ export function getActivePlatforms(config: DroidConfig): Platform[] {
   const ignored = config.ignored_platforms ?? [];
   return detected.filter(p => !ignored.includes(p));
 }
+
+/**
+ * Sync installed tools to newly detected platforms.
+ * Called early in common commands to handle platforms added after initial setup.
+ *
+ * Returns array of newly synced platforms (empty if none).
+ */
+export function syncNewPlatforms(config: DroidConfig): Platform[] {
+  const detected = detectAllPlatforms();
+  const ignored = config.ignored_platforms ?? [];
+  const active = detected.filter(p => !ignored.includes(p));
+
+  // Platforms already in config (have been initialized)
+  const initializedPlatforms = Object.keys(config.platforms ?? {}) as Platform[];
+
+  // Find newly detected platforms that aren't in config yet
+  const newPlatforms = active.filter(p => !initializedPlatforms.includes(p));
+
+  if (newPlatforms.length === 0) {
+    return [];
+  }
+
+  // Get installed skills from primary platform (claude-code)
+  const primaryTools = config.platforms?.['claude-code']?.tools ?? {};
+
+  // Initialize each new platform
+  for (const platform of newPlatforms) {
+    initializePlatformTools(platform, primaryTools, config);
+  }
+
+  return newPlatforms;
+}
+
+/**
+ * Initialize a newly detected platform with installed tools.
+ *
+ * For Codex: creates symlinks for tracked skills only (commands/agents not supported)
+ * For other platforms: would install commands/agents (not yet implemented)
+ */
+function initializePlatformTools(
+  platform: Platform,
+  primaryTools: Record<string, { version: string; installed_at: string; bundled_agents?: string[] }>,
+  config: DroidConfig,
+): void {
+  if (platform === Platform.OpenAICodex) {
+    // Codex: create symlinks only for skills tracked in config (not all skills in directory)
+    // This avoids syncing personal skills that weren't installed via droid
+    for (const skillName of Object.keys(primaryTools)) {
+      createCodexSymlink(skillName);
+    }
+
+    // Initialize platform section in config (mirrors primary platform's tools)
+    if (!config.platforms) {
+      config.platforms = {};
+    }
+    config.platforms[platform] = {
+      tools: { ...primaryTools },
+    };
+    return;
+  }
+
+  // For other platforms (Cursor, OpenCode): would need to install commands/agents
+  // This is a future enhancement - for now, just mark as initialized
+  if (!config.platforms) {
+    config.platforms = {};
+  }
+  config.platforms[platform] = {
+    tools: { ...primaryTools },
+  };
+}
+

package/src/lib/skills.ts

@@ -29,6 +29,8 @@ import {
   getCommandsPath,
   getConfigPath,
   getActivePlatforms,
+  createCodexSymlink,
+  removeCodexSymlink,
 } from './platforms';
 import { loadToolManifest, isToolInstalled } from './tools';
 import { runToolMigrations } from './migrations';
@@ -56,15 +58,17 @@ export function getSkillsInstallPath(platform: Platform): string {
 
 /**
  * Get the commands installation path based on platform
+ * Returns null for platforms that don't support commands (e.g., OpenAI Codex)
  */
-export function getCommandsInstallPath(platform: Platform): string {
+export function getCommandsInstallPath(platform: Platform): string | null {
   return getCommandsPath(platform);
 }
 
 /**
  * Get the path to the platform's main config markdown file
+ * Returns null for platforms without config file integration (e.g., OpenAI Codex)
  */
-export function getPlatformConfigPath(platform: Platform): string {
+export function getPlatformConfigPath(platform: Platform): string | null {
   return getConfigPath(platform);
 }
 
@@ -77,6 +81,11 @@ export function updatePlatformConfigSkills(
 ): void {
   const configPath = getPlatformConfigPath(platform);
 
+  // Skip platforms without config file integration (e.g., OpenAI Codex)
+  if (!configPath) {
+    return;
+  }
+
   let content = '';
   if (existsSync(configPath)) {
     content = readFileSync(configPath, 'utf-8');
@@ -472,7 +481,7 @@ export function installSkill(skillName: string): {
 
   const skillsPath = getSkillsInstallPath(config.platform);
   const targetSkillDir = join(skillsPath, skillName);
-  const commandsPath = getCommandsInstallPath(config.platform);
+  const commandsPath = getCommandsInstallPath(config.platform); // null for platforms without commands
   const tools = getPlatformTools(config);
 
   // Clean up old droid- prefixed directories from v0.18.x (Claude Code bug workaround)
@@ -527,7 +536,8 @@ export function installSkill(skillName: string): {
     const toolName = basename(toolDir);
 
     // Check command file collisions (these could conflict with other skills)
-    if (existsSync(commandsSource)) {
+    // Skip for platforms that don't support commands (e.g., OpenAI Codex)
+    if (commandsPath && existsSync(commandsSource)) {
       const commandFiles = readdirSync(commandsSource).filter(
         (f) => f.endsWith('.md') && f.toLowerCase() !== 'readme.md',
       );
@@ -608,8 +618,14 @@ export function installSkill(skillName: string): {
     ? activePlatforms
     : [config.platform]; // Fallback to primary platform
 
+  // Create Codex symlink if Codex is an active platform
+  // Codex reads from ~/.codex/skills/ but skills are installed to ~/.claude/skills/
+  if (targetPlatforms.includes(Platform.OpenAICodex)) {
+    createCodexSymlink(skillName);
+  }
+
   // Copy commands if present (from tool level)
-  // Install to EACH active platform
+  // Install to EACH active platform that supports commands
   if (existsSync(commandsSource)) {
     const commandFiles = readdirSync(commandsSource).filter(
       (f) => f.endsWith('.md') && f.toLowerCase() !== 'readme.md',
@@ -617,6 +633,10 @@ export function installSkill(skillName: string): {
 
     for (const platform of targetPlatforms) {
       const platformCommandsPath = getCommandsInstallPath(platform);
+      // Skip platforms that don't support commands (e.g., OpenAI Codex)
+      if (!platformCommandsPath) {
+        continue;
+      }
       if (!existsSync(platformCommandsPath)) {
         mkdirSync(platformCommandsPath, { recursive: true });
       }
@@ -725,6 +745,9 @@ export function uninstallSkill(skillName: string): {
     ? activePlatforms
     : [config.platform]; // Fallback to primary platform
 
+  // Remove Codex symlink if it exists (before removing the actual skill)
+  removeCodexSymlink(skillName);
+
   // Remove skill files from unified location
   const skillsPath = getSkillsInstallPath(config.platform);
   const skillDir = join(skillsPath, skillName);
@@ -732,7 +755,7 @@ export function uninstallSkill(skillName: string): {
     rmSync(skillDir, { recursive: true });
   }
 
-  // Remove command files from EACH active platform
+  // Remove command files from EACH active platform that supports commands
   const skillPath = findSkillPath(skillName);
   const commandsSource = skillPath ? join(skillPath.toolDir, 'commands') : null;
   if (commandsSource && existsSync(commandsSource)) {
@@ -742,6 +765,10 @@ export function uninstallSkill(skillName: string): {
 
     for (const platform of targetPlatforms) {
       const platformCommandsPath = getCommandsInstallPath(platform);
+      // Skip platforms that don't support commands (e.g., OpenAI Codex)
+      if (!platformCommandsPath) {
+        continue;
+      }
       for (const file of commandFiles) {
         const commandPath = join(platformCommandsPath, file);
         if (existsSync(commandPath)) {
@@ -829,6 +856,11 @@ export function isCommandInstalled(
   const config = loadConfig();
   const commandsPath = getCommandsInstallPath(config.platform);
 
+  // Platform doesn't support commands (e.g., OpenAI Codex)
+  if (!commandsPath) {
+    return false;
+  }
+
   // Command filename is derived from the command name after the skill prefix
   // e.g., "comments check" from skill "comments" → "check.md"
   const cmdPart = commandName.startsWith(skillName + ' ')
@@ -884,6 +916,13 @@ export function installCommand(
 
   // Ensure commands directory exists
   const commandsPath = getCommandsInstallPath(config.platform);
+  // Platform doesn't support commands (e.g., OpenAI Codex)
+  if (!commandsPath) {
+    return {
+      success: false,
+      message: `Platform ${config.platform} does not support custom commands`,
+    };
+  }
   if (!existsSync(commandsPath)) {
     mkdirSync(commandsPath, { recursive: true });
   }
@@ -919,6 +958,14 @@ export function uninstallCommand(
 
   const commandsPath = getCommandsInstallPath(config.platform);
 
+  // Platform doesn't support commands (e.g., OpenAI Codex)
+  if (!commandsPath) {
+    return {
+      success: false,
+      message: `Platform ${config.platform} does not support custom commands`,
+    };
+  }
+
   // Find the installed command file
   const cmdPart = commandName.startsWith(skillName + ' ')
     ? commandName.slice(skillName.length + 1)