@orderful/droid 0.37.0 → 0.39.0

package/dist/bin/droid.js

@@ -2,14 +2,15 @@
 
 // src/bin/droid.ts
 import { program } from "commander";
+import chalk12 from "chalk";
 
 // src/commands/setup.ts
 import inquirer from "inquirer";
 import chalk2 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/lib/config.ts
 import {
@@ -297,49 +298,124 @@ function removeRepo(name) {
 
 // src/lib/skills.ts
 import {
-  existsSync as existsSync6,
-  readdirSync as readdirSync5,
+  existsSync as existsSync7,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync6,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   writeFileSync as writeFileSync4,
-  rmSync as rmSync2
+  rmSync as rmSync3
 } from "fs";
-import { join as join7, dirname as dirname5, basename } from "path";
+import { join as join8, dirname as dirname6, basename } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import YAML4 from "yaml";
 
 // src/lib/agents.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5, dirname as dirname3 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import YAML3 from "yaml";
 
 // src/lib/platforms.ts
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 import { execSync } from "child_process";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
+
+// src/lib/platform.codex.ts
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  rmSync,
+  symlinkSync,
+  lstatSync,
+  readdirSync as readdirSync2,
+  readlinkSync
+} from "fs";
 var UNIFIED_SKILLS_PATH = join2(homedir2(), ".claude", "skills");
+var CODEX_SKILLS_PATH = join2(homedir2(), ".codex", "skills");
+function createCodexSymlink(skillName) {
+  const source = join2(UNIFIED_SKILLS_PATH, skillName);
+  const target = join2(CODEX_SKILLS_PATH, skillName);
+  if (!existsSync2(source)) {
+    console.warn(`Warning: Cannot create Codex symlink - source skill not found: ${source}`);
+    return;
+  }
+  if (!existsSync2(dirname(target))) {
+    mkdirSync2(dirname(target), { recursive: true });
+  }
+  if (existsSync2(target)) {
+    try {
+      const stat = lstatSync(target);
+      if (stat.isSymbolicLink()) {
+        const currentTarget = readlinkSync(target);
+        if (currentTarget === source) {
+          return;
+        }
+        rmSync(target);
+      } else {
+        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;
+    }
+  }
+  try {
+    symlinkSync(source, target);
+  } catch (error) {
+    console.warn(`Warning: Could not create Codex symlink ${target} \u2192 ${source}: ${error}`);
+  }
+}
+function removeCodexSymlink(skillName) {
+  const target = join2(CODEX_SKILLS_PATH, skillName);
+  if (!existsSync2(target)) {
+    return;
+  }
+  try {
+    const stat = lstatSync(target);
+    if (stat.isSymbolicLink()) {
+      rmSync(target);
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not remove Codex symlink ${target}: ${error}`);
+  }
+}
+
+// src/lib/platforms.ts
+var UNIFIED_SKILLS_PATH2 = join3(homedir3(), ".claude", "skills");
 var PLATFORM_PATHS = {
   ["claude-code" /* ClaudeCode */]: {
-    skills: UNIFIED_SKILLS_PATH,
-    commands: join2(homedir2(), ".claude", "commands"),
-    agents: join2(homedir2(), ".claude", "agents"),
-    config: join2(homedir2(), ".claude", "CLAUDE.md")
+    skills: UNIFIED_SKILLS_PATH2,
+    commands: join3(homedir3(), ".claude", "commands"),
+    agents: join3(homedir3(), ".claude", "agents"),
+    config: join3(homedir3(), ".claude", "CLAUDE.md")
   },
   ["opencode" /* OpenCode */]: {
-    skills: UNIFIED_SKILLS_PATH,
-    commands: join2(homedir2(), ".config", "opencode", "command"),
-    agents: join2(homedir2(), ".config", "opencode", "agent"),
-    config: join2(homedir2(), ".config", "opencode", "AGENTS.md")
+    skills: UNIFIED_SKILLS_PATH2,
+    commands: join3(homedir3(), ".config", "opencode", "command"),
+    agents: join3(homedir3(), ".config", "opencode", "agent"),
+    config: join3(homedir3(), ".config", "opencode", "AGENTS.md")
   },
   ["cursor" /* Cursor */]: {
-    skills: UNIFIED_SKILLS_PATH,
+    skills: UNIFIED_SKILLS_PATH2,
     // Cursor doesn't have a documented global commands path - commands are discovered from projects
     // We use this path as a placeholder; commands may not work the same as Claude Code/OpenCode
-    commands: join2(homedir2(), ".cursor", "commands"),
-    agents: join2(homedir2(), ".cursor", "agents"),
-    config: join2(homedir2(), ".cursor", "rules")
+    commands: join3(homedir3(), ".cursor", "commands"),
+    agents: join3(homedir3(), ".cursor", "agents"),
+    config: join3(homedir3(), ".cursor", "rules")
+  },
+  ["openai-codex" /* OpenAICodex */]: {
+    // Codex reads from ~/.codex/skills/ but we install to unified path and symlink
+    skills: UNIFIED_SKILLS_PATH2,
+    commands: null,
+    // Not supported - Codex has built-in commands only
+    agents: null,
+    // Not supported - Codex is single-agent
+    config: null
+    // No config file integration
   }
 };
 function getSkillsPath(platform) {
@@ -361,8 +437,8 @@ function detectAllPlatforms() {
     detected.push("claude-code" /* ClaudeCode */);
   } catch {
   }
-  const cursorDir = join2(homedir2(), ".cursor");
-  if (existsSync2(cursorDir)) {
+  const cursorDir = join3(homedir3(), ".cursor");
+  if (existsSync3(cursorDir)) {
     detected.push("cursor" /* Cursor */);
   }
   try {
@@ -370,6 +446,10 @@ function detectAllPlatforms() {
     detected.push("opencode" /* OpenCode */);
   } catch {
   }
+  const codexDir = join3(homedir3(), ".codex");
+  if (existsSync3(codexDir)) {
+    detected.push("openai-codex" /* OpenAICodex */);
+  }
   return detected;
 }
 function getActivePlatforms(config) {
@@ -377,21 +457,56 @@ function getActivePlatforms(config) {
   const ignored = config.ignored_platforms ?? [];
   return detected.filter((p) => !ignored.includes(p));
 }
+function syncNewPlatforms(config) {
+  const detected = detectAllPlatforms();
+  const ignored = config.ignored_platforms ?? [];
+  const active = detected.filter((p) => !ignored.includes(p));
+  const initializedPlatforms = Object.keys(config.platforms ?? {});
+  const newPlatforms = active.filter((p) => !initializedPlatforms.includes(p));
+  if (newPlatforms.length === 0) {
+    return [];
+  }
+  const primaryTools = config.platforms?.["claude-code"]?.tools ?? {};
+  for (const platform of newPlatforms) {
+    initializePlatformTools(platform, primaryTools, config);
+  }
+  return newPlatforms;
+}
+function initializePlatformTools(platform, primaryTools, config) {
+  if (platform === "openai-codex" /* OpenAICodex */) {
+    for (const skillName of Object.keys(primaryTools)) {
+      createCodexSymlink(skillName);
+    }
+    if (!config.platforms) {
+      config.platforms = {};
+    }
+    config.platforms[platform] = {
+      tools: { ...primaryTools }
+    };
+    return;
+  }
+  if (!config.platforms) {
+    config.platforms = {};
+  }
+  config.platforms[platform] = {
+    tools: { ...primaryTools }
+  };
+}
 
 // src/lib/tools.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import YAML2 from "yaml";
 
 // src/lib/version.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 import { execSync as execSync2 } from "child_process";
 import chalk from "chalk";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var packageJsonPath = join3(__dirname, "../../package.json");
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var packageJsonPath = join4(__dirname, "../../package.json");
 function getVersion() {
   try {
     const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
@@ -445,14 +560,14 @@ function runUpdate() {
 }
 
 // src/lib/tools.ts
-var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
-var BUNDLED_TOOLS_DIR = join4(__dirname2, "../tools");
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var BUNDLED_TOOLS_DIR = join5(__dirname2, "../tools");
 function getBundledToolsDir() {
   return BUNDLED_TOOLS_DIR;
 }
 function loadToolManifest(toolDir) {
-  const manifestPath = join4(toolDir, "TOOL.yaml");
-  if (!existsSync3(manifestPath)) {
+  const manifestPath = join5(toolDir, "TOOL.yaml");
+  if (!existsSync4(manifestPath)) {
     return null;
   }
   try {
@@ -472,13 +587,13 @@ function loadToolManifest(toolDir) {
   }
 }
 function getBundledTools() {
-  if (!existsSync3(BUNDLED_TOOLS_DIR)) {
+  if (!existsSync4(BUNDLED_TOOLS_DIR)) {
     return [];
   }
-  const toolDirs = readdirSync2(BUNDLED_TOOLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  const toolDirs = readdirSync3(BUNDLED_TOOLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
   const tools = [];
   for (const toolName of toolDirs) {
-    const manifest = loadToolManifest(join4(BUNDLED_TOOLS_DIR, toolName));
+    const manifest = loadToolManifest(join5(BUNDLED_TOOLS_DIR, toolName));
     if (manifest) {
       tools.push(manifest);
     }
@@ -547,8 +662,8 @@ function getToolsWithUpdates() {
 }
 
 // src/lib/agents.ts
-var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
-var BUNDLED_TOOLS_DIR2 = join5(__dirname3, "../tools");
+var __dirname3 = dirname4(fileURLToPath3(import.meta.url));
+var BUNDLED_TOOLS_DIR2 = join6(__dirname3, "../tools");
 function getAgentsInstallPath(platform) {
   return getAgentsPath(platform);
 }
@@ -569,7 +684,7 @@ function parseAgentFrontmatter(content) {
   }
 }
 function loadAgentManifest(agentPath) {
-  if (!existsSync4(agentPath)) {
+  if (!existsSync5(agentPath)) {
     return null;
   }
   const content = readFileSync4(agentPath, "utf-8");
@@ -577,7 +692,7 @@ function loadAgentManifest(agentPath) {
   if (!frontmatter || !frontmatter.name) {
     return null;
   }
-  const toolDir = dirname3(dirname3(agentPath));
+  const toolDir = dirname4(dirname4(agentPath));
   const toolManifest = loadToolManifest(toolDir);
   return {
     name: frontmatter.name,
@@ -597,8 +712,9 @@ function getInstalledAgentsDir() {
 function isAgentInstalled(agentName) {
   const config = loadConfig();
   const agentsDir = getAgentsInstallPath(config.platform);
-  const agentPath = join5(agentsDir, `${agentName}.md`);
-  return existsSync4(agentPath);
+  if (!agentsDir) return false;
+  const agentPath = join6(agentsDir, `${agentName}.md`);
+  return existsSync5(agentPath);
 }
 function generateClaudeCodeAgent(manifest, agentContent) {
   const lines = [
@@ -644,10 +760,13 @@ function installAgentFromPath(agentPath, agentName, platform) {
     const agentContent = frontmatterMatch ? rawContent.slice(frontmatterMatch[0].length) : rawContent;
     const installedContent = targetPlatform === "claude-code" /* ClaudeCode */ ? generateClaudeCodeAgent(manifest, agentContent) : generateOpenCodeAgent(manifest, agentContent);
     const agentsDir = getAgentsInstallPath(targetPlatform);
-    if (!existsSync4(agentsDir)) {
-      mkdirSync2(agentsDir, { recursive: true });
+    if (!agentsDir) {
+      return { success: false, message: `Platform ${targetPlatform} does not support agents` };
+    }
+    if (!existsSync5(agentsDir)) {
+      mkdirSync3(agentsDir, { recursive: true });
     }
-    const outputPath = join5(agentsDir, `${agentName}.md`);
+    const outputPath = join6(agentsDir, `${agentName}.md`);
     writeFileSync2(outputPath, installedContent);
     const targetDir = targetPlatform === "claude-code" /* ClaudeCode */ ? "~/.claude/agents/" : targetPlatform === "cursor" /* Cursor */ ? "~/.cursor/agents/" : "~/.config/opencode/agent/";
     return { success: true, message: `Installed ${agentName} to ${targetDir}` };
@@ -659,8 +778,11 @@ function uninstallAgent(agentName, platform) {
   const config = loadConfig();
   const targetPlatform = platform ?? config.platform;
   const agentsDir = getAgentsInstallPath(targetPlatform);
-  const agentPath = join5(agentsDir, `${agentName}.md`);
-  if (!existsSync4(agentPath)) {
+  if (!agentsDir) {
+    return { success: true, message: `Platform ${targetPlatform} does not support agents` };
+  }
+  const agentPath = join6(agentsDir, `${agentName}.md`);
+  if (!existsSync5(agentPath)) {
     return { success: false, message: `Agent not installed: ${agentName}` };
   }
   try {
@@ -673,20 +795,20 @@ function uninstallAgent(agentName, platform) {
 
 // src/lib/migrations.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   appendFileSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   renameSync,
-  rmSync,
-  readdirSync as readdirSync4,
+  rmSync as rmSync2,
+  readdirSync as readdirSync5,
   readFileSync as readFileSync5,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join6, dirname as dirname4 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join7, dirname as dirname5 } from "path";
+import { homedir as homedir4 } from "os";
 var MIGRATIONS_LOG_FILE = ".migrations.log";
 function getMigrationsLogPath() {
-  return join6(getConfigDir(), MIGRATIONS_LOG_FILE);
+  return join7(getConfigDir(), MIGRATIONS_LOG_FILE);
 }
 function logMigration(toolName, fromVersion, toVersion, status, error) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -694,9 +816,9 @@ function logMigration(toolName, fromVersion, toVersion, status, error) {
 ` : `${timestamp} ${toolName} ${fromVersion} \u2192 ${toVersion} ${status}
 `;
   const logPath = getMigrationsLogPath();
-  const logDir = dirname4(logPath);
-  if (!existsSync5(logDir)) {
-    mkdirSync3(logDir, { recursive: true });
+  const logDir = dirname5(logPath);
+  if (!existsSync6(logDir)) {
+    mkdirSync4(logDir, { recursive: true });
   }
   appendFileSync(logPath, logEntry);
 }
@@ -706,16 +828,16 @@ function createConfigDirMigration(skillName, version2) {
     version: version2,
     description: `Move ${skillName} config to unprefixed location`,
     up: (configDir) => {
-      const oldDir = join6(configDir, "skills", skillName);
-      const newDir = join6(configDir, "skills", unprefixedName);
-      if (existsSync5(oldDir) && !existsSync5(newDir)) {
-        const parentDir = dirname4(newDir);
-        if (!existsSync5(parentDir)) {
-          mkdirSync3(parentDir, { recursive: true });
+      const oldDir = join7(configDir, "skills", skillName);
+      const newDir = join7(configDir, "skills", unprefixedName);
+      if (existsSync6(oldDir) && !existsSync6(newDir)) {
+        const parentDir = dirname5(newDir);
+        if (!existsSync6(parentDir)) {
+          mkdirSync4(parentDir, { recursive: true });
         }
         renameSync(oldDir, newDir);
-      } else if (existsSync5(oldDir) && existsSync5(newDir)) {
-        rmSync(oldDir, { recursive: true });
+      } else if (existsSync6(oldDir) && existsSync6(newDir)) {
+        rmSync2(oldDir, { recursive: true });
       }
     }
   };
@@ -731,10 +853,10 @@ function createPlatformSyncMigration(version2) {
       const originalPlatform = config.platform;
       for (const platformKey of ["claude-code" /* ClaudeCode */, "opencode" /* OpenCode */, "cursor" /* Cursor */]) {
         const skillsPath = getSkillsPath(platformKey);
-        if (!existsSync5(skillsPath)) continue;
+        if (!existsSync6(skillsPath)) continue;
         config.platform = platformKey;
         const trackedTools = getPlatformTools(config);
-        const installedDirs = readdirSync4(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        const installedDirs = readdirSync5(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
         for (const skillName of installedDirs) {
           const normalizedName = skillName.replace(/^droid-/, "");
           const isTracked = trackedTools[skillName] || trackedTools[`droid-${normalizedName}`] || trackedTools[normalizedName];
@@ -807,12 +929,12 @@ function createOpenCodeSkillsPathMigration(version2) {
       if (config.platform !== "opencode" /* OpenCode */) {
         return;
       }
-      const oldSkillsPath = join6(getSkillsPath("opencode" /* OpenCode */), "..", "skills");
+      const oldSkillsPath = join7(getSkillsPath("opencode" /* OpenCode */), "..", "skills");
       const newSkillsPath = getSkillsPath("opencode" /* OpenCode */);
-      if (!existsSync5(oldSkillsPath)) {
+      if (!existsSync6(oldSkillsPath)) {
         return;
       }
-      if (!existsSync5(newSkillsPath)) {
+      if (!existsSync6(newSkillsPath)) {
         try {
           renameSync(oldSkillsPath, newSkillsPath);
         } catch (error) {
@@ -822,11 +944,11 @@ function createOpenCodeSkillsPathMigration(version2) {
         }
         return;
       }
-      const skillDirs = readdirSync4(oldSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+      const skillDirs = readdirSync5(oldSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
       for (const skillName of skillDirs) {
-        const oldSkillDir = join6(oldSkillsPath, skillName);
-        const newSkillDir = join6(newSkillsPath, skillName);
-        if (!existsSync5(newSkillDir)) {
+        const oldSkillDir = join7(oldSkillsPath, skillName);
+        const newSkillDir = join7(newSkillsPath, skillName);
+        if (!existsSync6(newSkillDir)) {
           try {
             renameSync(oldSkillDir, newSkillDir);
           } catch (error) {
@@ -837,9 +959,9 @@ function createOpenCodeSkillsPathMigration(version2) {
         }
       }
       try {
-        const remaining = readdirSync4(oldSkillsPath);
+        const remaining = readdirSync5(oldSkillsPath);
         if (remaining.length === 0) {
-          rmSync(oldSkillsPath, { recursive: true });
+          rmSync2(oldSkillsPath, { recursive: true });
         }
       } catch (error) {
         console.warn(
@@ -855,25 +977,25 @@ function createClaudeCodeCommandCleanupMigration(version2) {
     description: "Remove non-alias commands from Claude Code",
     up: () => {
       const commandsPath = getCommandsPath("claude-code" /* ClaudeCode */);
-      if (!existsSync5(commandsPath)) {
+      if (!commandsPath || !existsSync6(commandsPath)) {
         return;
       }
       const bundledTools = getBundledTools();
-      const aliasCommands = /* @__PURE__ */ new Set();
+      const deletableDroidCommands = /* @__PURE__ */ new Set();
       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);
           }
         }
       }
-      const commandFiles = readdirSync4(commandsPath, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name);
+      const commandFiles = readdirSync5(commandsPath, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name);
       for (const file of commandFiles) {
         const commandName = file.replace(".md", "");
-        if (!aliasCommands.has(commandName)) {
-          const commandFilePath = join6(commandsPath, file);
+        if (deletableDroidCommands.has(commandName)) {
+          const commandFilePath = join7(commandsPath, file);
           try {
-            rmSync(commandFilePath);
+            rmSync2(commandFilePath);
           } catch (error) {
             console.warn(
               `Warning: Could not remove command ${commandFilePath}: ${error}`
@@ -889,13 +1011,13 @@ function createOpenCodePluginCleanupMigration(version2) {
     version: version2,
     description: "Remove opencode-skills plugin from opencode.json",
     up: () => {
-      const opencodeConfigPath = join6(
-        homedir3(),
+      const opencodeConfigPath = join7(
+        homedir4(),
         ".config",
         "opencode",
         "opencode.json"
       );
-      if (!existsSync5(opencodeConfigPath)) {
+      if (!existsSync6(opencodeConfigPath)) {
         return;
       }
       let config;
@@ -932,24 +1054,24 @@ function createUnifiedSkillsPathMigration(version2) {
     version: version2,
     description: "Copy OpenCode skills to unified ~/.claude/skills/ location",
     up: () => {
-      const oldOpenCodeSkillsPath = join6(
-        homedir3(),
+      const oldOpenCodeSkillsPath = join7(
+        homedir4(),
         ".config",
         "opencode",
         "skill"
       );
-      const unifiedSkillsPath = join6(homedir3(), ".claude", "skills");
-      if (!existsSync5(oldOpenCodeSkillsPath)) {
+      const unifiedSkillsPath = join7(homedir4(), ".claude", "skills");
+      if (!existsSync6(oldOpenCodeSkillsPath)) {
         return;
       }
-      if (!existsSync5(unifiedSkillsPath)) {
-        mkdirSync3(unifiedSkillsPath, { recursive: true });
+      if (!existsSync6(unifiedSkillsPath)) {
+        mkdirSync4(unifiedSkillsPath, { recursive: true });
       }
-      const skillDirs = readdirSync4(oldOpenCodeSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+      const skillDirs = readdirSync5(oldOpenCodeSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
       for (const skillName of skillDirs) {
-        const sourcePath = join6(oldOpenCodeSkillsPath, skillName);
-        const destPath = join6(unifiedSkillsPath, skillName);
-        if (existsSync5(destPath)) {
+        const sourcePath = join7(oldOpenCodeSkillsPath, skillName);
+        const destPath = join7(unifiedSkillsPath, skillName);
+        if (existsSync6(destPath)) {
           continue;
         }
         try {
@@ -964,11 +1086,11 @@ function createUnifiedSkillsPathMigration(version2) {
   };
 }
 function copyDirRecursive(src, dest) {
-  mkdirSync3(dest, { recursive: true });
-  const entries = readdirSync4(src, { withFileTypes: true });
+  mkdirSync4(dest, { recursive: true });
+  const entries = readdirSync5(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join6(src, entry.name);
-    const destPath = join6(dest, entry.name);
+    const srcPath = join7(src, entry.name);
+    const destPath = join7(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
@@ -977,6 +1099,49 @@ function copyDirRecursive(src, dest) {
     }
   }
 }
+function createOpenCodeSkillsCleanupMigration(version2) {
+  return {
+    version: version2,
+    description: "Remove droid-managed skills from OpenCode platform-specific directory",
+    up: () => {
+      const oldOpenCodeSkillsPath = join7(
+        homedir4(),
+        ".config",
+        "opencode",
+        "skill"
+      );
+      const unifiedSkillsPath = join7(homedir4(), ".claude", "skills");
+      if (!existsSync6(oldOpenCodeSkillsPath)) {
+        return;
+      }
+      const bundledTools = getBundledTools();
+      const droidManagedSkills = /* @__PURE__ */ new Set();
+      for (const tool of bundledTools) {
+        for (const skill of tool.includes.skills) {
+          droidManagedSkills.add(skill.name);
+        }
+      }
+      const skillDirs = readdirSync5(oldOpenCodeSkillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+      for (const skillName of skillDirs) {
+        if (!droidManagedSkills.has(skillName)) {
+          continue;
+        }
+        const unifiedPath = join7(unifiedSkillsPath, skillName);
+        if (!existsSync6(unifiedPath)) {
+          continue;
+        }
+        const oldPath = join7(oldOpenCodeSkillsPath, skillName);
+        try {
+          rmSync2(oldPath, { recursive: true });
+        } catch (error) {
+          console.warn(
+            `Warning: Could not remove OpenCode skill ${skillName}: ${error}`
+          );
+        }
+      }
+    }
+  };
+}
 var PACKAGE_MIGRATIONS = [
   createPlatformSyncMigration("0.25.0"),
   createConfigSkillNameMigration("0.27.2"),
@@ -985,7 +1150,8 @@ var PACKAGE_MIGRATIONS = [
   // Retry: 0.28.0 migration had platform check that prevented running after platform switch
   createClaudeCodeCommandCleanupMigration("0.28.1"),
   createOpenCodePluginCleanupMigration("0.29.2"),
-  createUnifiedSkillsPathMigration("0.30.0")
+  createUnifiedSkillsPathMigration("0.30.0"),
+  createOpenCodeSkillsCleanupMigration("0.37.1")
 ];
 var TOOL_MIGRATIONS = {
   brain: [createConfigDirMigration("droid-brain", "0.2.3")],
@@ -1109,8 +1275,8 @@ function runPackageMigrations(packageVersion) {
 // src/lib/skills.ts
 var DROID_SKILLS_START = "<!-- droid-skills-start -->";
 var DROID_SKILLS_END = "<!-- droid-skills-end -->";
-var __dirname4 = dirname5(fileURLToPath4(import.meta.url));
-var BUNDLED_SKILLS_DIR = join7(__dirname4, "../tools");
+var __dirname4 = dirname6(fileURLToPath4(import.meta.url));
+var BUNDLED_SKILLS_DIR = join8(__dirname4, "../tools");
 function getSkillsInstallPath(platform) {
   return getSkillsPath(platform);
 }
@@ -1122,8 +1288,11 @@ function getPlatformConfigPath(platform) {
 }
 function updatePlatformConfigSkills(platform, installedSkills) {
   const configPath = getPlatformConfigPath(platform);
+  if (!configPath) {
+    return;
+  }
   let content = "";
-  if (existsSync6(configPath)) {
+  if (existsSync7(configPath)) {
     content = readFileSync6(configPath, "utf-8");
   }
   const skillLines = installedSkills.map((name) => {
@@ -1142,9 +1311,9 @@ ${DROID_SKILLS_END}` : "";
   } else if (skillsSection) {
     content = content.trim() + "\n\n" + skillsSection + "\n";
   }
-  const configDir = dirname5(configPath);
-  if (!existsSync6(configDir)) {
-    mkdirSync4(configDir, { recursive: true });
+  const configDir = dirname6(configPath);
+  if (!existsSync7(configDir)) {
+    mkdirSync5(configDir, { recursive: true });
   }
   writeFileSync4(configPath, content, "utf-8");
 }
@@ -1165,8 +1334,8 @@ function parseSkillFrontmatter(content) {
   }
 }
 function loadSkillManifest(skillDir) {
-  const skillMdPath = join7(skillDir, "SKILL.md");
-  if (!existsSync6(skillMdPath)) {
+  const skillMdPath = join8(skillDir, "SKILL.md");
+  if (!existsSync7(skillMdPath)) {
     return null;
   }
   const content = readFileSync6(skillMdPath, "utf-8");
@@ -1174,7 +1343,7 @@ function loadSkillManifest(skillDir) {
   if (!frontmatter || !frontmatter.name) {
     return null;
   }
-  const toolDir = dirname5(dirname5(skillDir));
+  const toolDir = dirname6(dirname6(skillDir));
   const toolManifest = loadToolManifest(toolDir);
   return {
     name: frontmatter.name,
@@ -1186,17 +1355,17 @@ function loadSkillManifest(skillDir) {
   };
 }
 function findSkillPath(skillName) {
-  if (!existsSync6(BUNDLED_SKILLS_DIR)) {
+  if (!existsSync7(BUNDLED_SKILLS_DIR)) {
     return null;
   }
-  const toolDirs = readdirSync5(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  const toolDirs = readdirSync6(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
   for (const toolName of toolDirs) {
-    const skillsDir = join7(BUNDLED_SKILLS_DIR, toolName, "skills");
-    if (!existsSync6(skillsDir)) continue;
-    const skillDir = join7(skillsDir, skillName);
-    if (existsSync6(skillDir) && existsSync6(join7(skillDir, "SKILL.md"))) {
+    const skillsDir = join8(BUNDLED_SKILLS_DIR, toolName, "skills");
+    if (!existsSync7(skillsDir)) continue;
+    const skillDir = join8(skillsDir, skillName);
+    if (existsSync7(skillDir) && existsSync7(join8(skillDir, "SKILL.md"))) {
       return {
-        toolDir: join7(BUNDLED_SKILLS_DIR, toolName),
+        toolDir: join8(BUNDLED_SKILLS_DIR, toolName),
         skillDir
       };
     }
@@ -1204,17 +1373,17 @@ function findSkillPath(skillName) {
   return null;
 }
 function getBundledSkills() {
-  if (!existsSync6(BUNDLED_SKILLS_DIR)) {
+  if (!existsSync7(BUNDLED_SKILLS_DIR)) {
     return [];
   }
-  const toolDirs = readdirSync5(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  const toolDirs = readdirSync6(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
   const skills = [];
   for (const toolName of toolDirs) {
-    const skillsDir = join7(BUNDLED_SKILLS_DIR, toolName, "skills");
-    if (!existsSync6(skillsDir)) continue;
-    const skillSubdirs = readdirSync5(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const skillsDir = join8(BUNDLED_SKILLS_DIR, toolName, "skills");
+    if (!existsSync7(skillsDir)) continue;
+    const skillSubdirs = readdirSync6(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     for (const skillName of skillSubdirs) {
-      const manifest = loadSkillManifest(join7(skillsDir, skillName));
+      const manifest = loadSkillManifest(join8(skillsDir, skillName));
       if (manifest) {
         skills.push(manifest);
       }
@@ -1306,13 +1475,13 @@ function updateAllSkills() {
   return result;
 }
 function copyDirectoryRecursive(source, target, fileFilter) {
-  if (!existsSync6(target)) {
-    mkdirSync4(target, { recursive: true });
+  if (!existsSync7(target)) {
+    mkdirSync5(target, { recursive: true });
   }
-  const entries = readdirSync5(source, { withFileTypes: true });
+  const entries = readdirSync6(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join7(source, entry.name);
-    const targetPath = join7(target, entry.name);
+    const sourcePath = join8(source, entry.name);
+    const targetPath = join8(target, entry.name);
     if (entry.isDirectory()) {
       copyDirectoryRecursive(sourcePath, targetPath, fileFilter);
     } else if (entry.isFile() && fileFilter(entry.name)) {
@@ -1353,7 +1522,7 @@ function installSkill(skillName) {
     }
   }
   const skillsPath = getSkillsInstallPath(config.platform);
-  const targetSkillDir = join7(skillsPath, skillName);
+  const targetSkillDir = join8(skillsPath, skillName);
   const commandsPath = getCommandsInstallPath(config.platform);
   const tools = getPlatformTools(config);
   const renamedSkills = [
@@ -1368,10 +1537,10 @@ function installSkill(skillName) {
   ];
   if (renamedSkills.includes(skillName)) {
     const droidPrefixedName = `droid-${skillName}`;
-    const droidPrefixedDir = join7(skillsPath, droidPrefixedName);
-    if (existsSync6(droidPrefixedDir)) {
+    const droidPrefixedDir = join8(skillsPath, droidPrefixedName);
+    if (existsSync7(droidPrefixedDir)) {
       try {
-        rmSync2(droidPrefixedDir, { recursive: true });
+        rmSync3(droidPrefixedDir, { recursive: true });
       } catch (error) {
         console.warn(
           `Warning: Could not remove old skill directory ${droidPrefixedDir}: ${error}`
@@ -1384,18 +1553,18 @@ function installSkill(skillName) {
       saveConfig(config);
     }
   }
-  const commandsSource = join7(toolDir, "commands");
-  const agentsSource = join7(toolDir, "agents");
+  const commandsSource = join8(toolDir, "commands");
+  const agentsSource = join8(toolDir, "agents");
   const isAlreadyInstalled = tools[skillName];
   if (!isAlreadyInstalled) {
     const toolName2 = basename(toolDir);
-    if (existsSync6(commandsSource)) {
-      const commandFiles = readdirSync5(commandsSource).filter(
+    if (commandsPath && existsSync7(commandsSource)) {
+      const commandFiles = readdirSync6(commandsSource).filter(
         (f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md"
       );
       for (const file of commandFiles) {
-        const targetCommandPath = join7(commandsPath, file);
-        if (existsSync6(targetCommandPath)) {
+        const targetCommandPath = join8(commandsPath, file);
+        if (existsSync7(targetCommandPath)) {
           const commandName = file.replace(".md", "");
           if (commandName === toolName2) {
             continue;
@@ -1407,8 +1576,8 @@ function installSkill(skillName) {
         }
       }
     }
-    if (existsSync6(agentsSource)) {
-      const agentFiles = readdirSync5(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name.replace(".md", ""));
+    if (existsSync7(agentsSource)) {
+      const agentFiles = readdirSync6(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name.replace(".md", ""));
       for (const agentName of agentFiles) {
         if (isAgentInstalled(agentName)) {
           return {
@@ -1419,30 +1588,30 @@ function installSkill(skillName) {
       }
     }
   }
-  if (!existsSync6(skillsPath)) {
-    mkdirSync4(skillsPath, { recursive: true });
+  if (!existsSync7(skillsPath)) {
+    mkdirSync5(skillsPath, { recursive: true });
   }
-  const skillMdSource = join7(skillDir, "SKILL.md");
-  if (existsSync6(skillMdSource)) {
-    if (!existsSync6(targetSkillDir)) {
-      mkdirSync4(targetSkillDir, { recursive: true });
+  const skillMdSource = join8(skillDir, "SKILL.md");
+  if (existsSync7(skillMdSource)) {
+    if (!existsSync7(targetSkillDir)) {
+      mkdirSync5(targetSkillDir, { recursive: true });
     }
-    const skillMdTarget = join7(targetSkillDir, "SKILL.md");
+    const skillMdTarget = join8(targetSkillDir, "SKILL.md");
     const content = readFileSync6(skillMdSource, "utf-8");
     writeFileSync4(skillMdTarget, content);
   }
-  const referencesSource = join7(skillDir, "references");
-  if (existsSync6(referencesSource)) {
-    const targetReferencesDir = join7(targetSkillDir, "references");
+  const referencesSource = join8(skillDir, "references");
+  if (existsSync7(referencesSource)) {
+    const targetReferencesDir = join8(targetSkillDir, "references");
     copyDirectoryRecursive(
       referencesSource,
       targetReferencesDir,
       (f) => f.endsWith(".md")
     );
   }
-  const scriptsSource = join7(skillDir, "scripts");
-  if (existsSync6(scriptsSource)) {
-    const targetScriptsDir = join7(targetSkillDir, "scripts");
+  const scriptsSource = join8(skillDir, "scripts");
+  if (existsSync7(scriptsSource)) {
+    const targetScriptsDir = join8(targetSkillDir, "scripts");
     copyDirectoryRecursive(
       scriptsSource,
       targetScriptsDir,
@@ -1451,14 +1620,20 @@ function installSkill(skillName) {
   }
   const activePlatforms = getActivePlatforms(config);
   const targetPlatforms = activePlatforms.length > 0 ? activePlatforms : [config.platform];
-  if (existsSync6(commandsSource)) {
-    const commandFiles = readdirSync5(commandsSource).filter(
+  if (targetPlatforms.includes("openai-codex" /* OpenAICodex */)) {
+    createCodexSymlink(skillName);
+  }
+  if (existsSync7(commandsSource)) {
+    const commandFiles = readdirSync6(commandsSource).filter(
       (f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md"
     );
     for (const platform of targetPlatforms) {
       const platformCommandsPath = getCommandsInstallPath(platform);
-      if (!existsSync6(platformCommandsPath)) {
-        mkdirSync4(platformCommandsPath, { recursive: true });
+      if (!platformCommandsPath) {
+        continue;
+      }
+      if (!existsSync7(platformCommandsPath)) {
+        mkdirSync5(platformCommandsPath, { recursive: true });
       }
       for (const file of commandFiles) {
         const commandName = file.replace(".md", "");
@@ -1468,8 +1643,8 @@ function installSkill(skillName) {
         const isAlias = typeof commandMeta === "object" && commandMeta.is_alias;
         const shouldInstall = platform === "opencode" /* OpenCode */ || platform === "cursor" /* Cursor */ || isAlias;
         if (shouldInstall) {
-          const sourcePath = join7(commandsSource, file);
-          const targetPath = join7(platformCommandsPath, file);
+          const sourcePath = join8(commandsSource, file);
+          const targetPath = join8(platformCommandsPath, file);
           const content = readFileSync6(sourcePath, "utf-8");
           writeFileSync4(targetPath, content);
         }
@@ -1477,10 +1652,10 @@ function installSkill(skillName) {
     }
   }
   const installedAgents = [];
-  if (existsSync6(agentsSource)) {
-    const agentFiles = readdirSync5(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name.replace(".md", ""));
+  if (existsSync7(agentsSource)) {
+    const agentFiles = readdirSync6(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name.replace(".md", ""));
     for (const agentName of agentFiles) {
-      const agentPath = join7(agentsSource, `${agentName}.md`);
+      const agentPath = join8(agentsSource, `${agentName}.md`);
       let anySuccess = false;
       for (const platform of targetPlatforms) {
         const result = installAgentFromPath(agentPath, agentName, platform);
@@ -1527,23 +1702,27 @@ function uninstallSkill(skillName) {
   }
   const activePlatforms = getActivePlatforms(config);
   const targetPlatforms = activePlatforms.length > 0 ? activePlatforms : [config.platform];
+  removeCodexSymlink(skillName);
   const skillsPath = getSkillsInstallPath(config.platform);
-  const skillDir = join7(skillsPath, skillName);
-  if (existsSync6(skillDir)) {
-    rmSync2(skillDir, { recursive: true });
+  const skillDir = join8(skillsPath, skillName);
+  if (existsSync7(skillDir)) {
+    rmSync3(skillDir, { recursive: true });
   }
   const skillPath = findSkillPath(skillName);
-  const commandsSource = skillPath ? join7(skillPath.toolDir, "commands") : null;
-  if (commandsSource && existsSync6(commandsSource)) {
-    const commandFiles = readdirSync5(commandsSource).filter(
+  const commandsSource = skillPath ? join8(skillPath.toolDir, "commands") : null;
+  if (commandsSource && existsSync7(commandsSource)) {
+    const commandFiles = readdirSync6(commandsSource).filter(
       (f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md"
     );
     for (const platform of targetPlatforms) {
       const platformCommandsPath = getCommandsInstallPath(platform);
+      if (!platformCommandsPath) {
+        continue;
+      }
       for (const file of commandFiles) {
-        const commandPath = join7(platformCommandsPath, file);
-        if (existsSync6(commandPath)) {
-          rmSync2(commandPath);
+        const commandPath = join8(platformCommandsPath, file);
+        if (existsSync7(commandPath)) {
+          rmSync3(commandPath);
         }
       }
     }
@@ -1555,9 +1734,9 @@ function uninstallSkill(skillName) {
       agentsToRemove.add(agentName);
     }
   }
-  const agentsSource = skillPath ? join7(skillPath.toolDir, "agents") : null;
-  if (agentsSource && existsSync6(agentsSource)) {
-    const agentFiles = readdirSync5(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name.replace(".md", ""));
+  const agentsSource = skillPath ? join8(skillPath.toolDir, "agents") : null;
+  if (agentsSource && existsSync7(agentsSource)) {
+    const agentFiles = readdirSync6(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md")).map((dirent) => dirent.name.replace(".md", ""));
     for (const agentName of agentFiles) {
       agentsToRemove.add(agentName);
     }
@@ -1581,7 +1760,8 @@ function uninstallSkill(skillName) {
 var PLATFORM_LABELS = {
   ["claude-code" /* ClaudeCode */]: "Claude Code",
   ["cursor" /* Cursor */]: "Cursor",
-  ["opencode" /* OpenCode */]: "OpenCode"
+  ["opencode" /* OpenCode */]: "OpenCode",
+  ["openai-codex" /* OpenAICodex */]: "Codex"
 };
 var DROID_PERMISSIONS = [
   "Read(~/.droid/**)",
@@ -1590,6 +1770,75 @@ var DROID_PERMISSIONS = [
   "Glob(~/.droid/**)",
   "Grep(~/.droid/**)"
 ];
+var SKILL_OVERRIDES_TEMPLATE = `---
+overrides: []
+---
+
+# Skill Override Template
+
+Copy this file to \`{skill_name}.md\` to override a skill's behaviour.
+
+## Format
+
+\`\`\`yaml
+---
+overrides: [command1, command2]
+---
+\`\`\`
+
+Then add sections for each command you're overriding:
+
+\`\`\`markdown
+## {command1}
+
+Your custom instructions for this command...
+\`\`\`
+
+---
+
+## Example: Override brain search with qmd
+
+Create \`brain.md\` with:
+
+\`\`\`yaml
+---
+overrides: [search]
+---
+\`\`\`
+
+## search
+
+Use qmd for semantic search:
+
+1. Run \`qmd query "{query}" -c brain -n 10 --files\`
+2. Parse CSV output, extract filepath (field 3)
+3. If qmd fails, fall back to Glob
+
+---
+
+## Registration
+
+After creating an override file, ask droid to register it:
+
+> "Register my brain override"
+
+Droid will:
+1. Parse the frontmatter to find which commands are overridden
+2. Update config.yaml with override metadata
+3. The skill will use your override on next invocation
+`;
+function createSkillOverridesDir() {
+  const overridesDir = join9(getConfigDir(), "skill_overrides");
+  const templatePath = join9(overridesDir, "_template.md");
+  if (existsSync8(templatePath)) {
+    return { created: false, alreadyExists: true };
+  }
+  if (!existsSync8(overridesDir)) {
+    mkdirSync6(overridesDir, { recursive: true });
+  }
+  writeFileSync5(templatePath, SKILL_OVERRIDES_TEMPLATE, "utf-8");
+  return { created: true, alreadyExists: false };
+}
 function detectGitUsername() {
   try {
     return execSync3("git config user.name", { encoding: "utf-8" }).trim();
@@ -1600,13 +1849,13 @@ function detectGitUsername() {
 function configurePlatformPermissions(platform) {
   const added = [];
   if (platform === "claude-code" /* ClaudeCode */) {
-    const settingsPath = join8(homedir4(), ".claude", "settings.json");
-    const claudeDir = join8(homedir4(), ".claude");
-    if (!existsSync7(claudeDir)) {
-      mkdirSync5(claudeDir, { recursive: true });
+    const settingsPath = join9(homedir5(), ".claude", "settings.json");
+    const claudeDir = join9(homedir5(), ".claude");
+    if (!existsSync8(claudeDir)) {
+      mkdirSync6(claudeDir, { recursive: true });
     }
     let settings = {};
-    if (existsSync7(settingsPath)) {
+    if (existsSync8(settingsPath)) {
       try {
         settings = JSON.parse(readFileSync7(settingsPath, "utf-8"));
       } catch {
@@ -1637,20 +1886,20 @@ function configurePlatformPermissions(platform) {
     return { added, alreadyPresent: added.length === 0 };
   }
   if (platform === "opencode" /* OpenCode */) {
-    const globalConfigDir = join8(homedir4(), ".config", "opencode");
-    if (!existsSync7(globalConfigDir)) {
-      mkdirSync5(globalConfigDir, { recursive: true });
+    const globalConfigDir = join9(homedir5(), ".config", "opencode");
+    if (!existsSync8(globalConfigDir)) {
+      mkdirSync6(globalConfigDir, { recursive: true });
     }
     return { added: [], alreadyPresent: true };
   }
   if (platform === "cursor" /* Cursor */) {
-    const cursorDir = join8(homedir4(), ".cursor");
-    if (!existsSync7(cursorDir)) {
-      mkdirSync5(cursorDir, { recursive: true });
+    const cursorDir = join9(homedir5(), ".cursor");
+    if (!existsSync8(cursorDir)) {
+      mkdirSync6(cursorDir, { recursive: true });
     }
-    const agentsDir = join8(cursorDir, "agents");
-    if (!existsSync7(agentsDir)) {
-      mkdirSync5(agentsDir, { recursive: true });
+    const agentsDir = join9(cursorDir, "agents");
+    if (!existsSync8(agentsDir)) {
+      mkdirSync6(agentsDir, { recursive: true });
     }
     return { added: [], alreadyPresent: true };
   }
@@ -1758,6 +2007,12 @@ async function setupCommand() {
   };
   saveConfig(config);
   console.log(chalk2.green("\n\u2713 Config saved to ~/.droid/config.yaml"));
+  const { created: overridesCreated, alreadyExists: overridesExist } = createSkillOverridesDir();
+  if (overridesCreated) {
+    console.log(chalk2.green("\u2713 Created ~/.droid/skill_overrides/ with template"));
+  } else if (overridesExist) {
+    console.log(chalk2.gray("  Skill overrides directory already exists"));
+  }
   for (const platform of activePlatforms) {
     const { added, alreadyPresent, error } = configurePlatformPermissions(platform);
     if (error) {
@@ -1772,6 +2027,16 @@ async function setupCommand() {
       console.log(chalk2.gray(`  ${PLATFORM_LABELS[platform]} directories ready`));
     }
   }
+  if (activePlatforms.includes("openai-codex" /* OpenAICodex */)) {
+    const trackedTools = getPlatformTools(config);
+    const toolNames = Object.keys(trackedTools);
+    if (toolNames.length > 0) {
+      for (const skillName of toolNames) {
+        createCodexSymlink(skillName);
+      }
+      console.log(chalk2.green("\u2713 Created Codex symlinks for installed tools"));
+    }
+  }
   if (activePlatforms.length > 1) {
     console.log(chalk2.green(`
 \u2713 Will install to ${activePlatforms.length} platforms: ${activePlatforms.map((p) => PLATFORM_LABELS[p]).join(", ")}`));
@@ -2159,7 +2424,7 @@ async function uninstallCommand(toolName) {
 
 // src/commands/update.ts
 import chalk8 from "chalk";
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync5, spawnSync } from "child_process";
 async function updateCommand(tool, options) {
   if (tool) {
     console.log(chalk8.yellow("\n\u26A0 Per-tool updates not implemented yet"));
@@ -2214,6 +2479,22 @@ async function updateCommand(tool, options) {
     execSync5("npm install -g @orderful/droid@latest", { stdio: "inherit" });
     console.log(chalk8.green(`
 \u2713 Updated to v${latestVersion}`));
+    const autoUpdateConfig = getAutoUpdateConfig();
+    if (autoUpdateConfig.tools) {
+      console.log(chalk8.bold("\n\u{1F916} Syncing tools...\n"));
+      const toolResult = spawnSync("droid", ["update", "--tools"], {
+        stdio: "inherit",
+        timeout: 6e4
+        // 60s timeout for tool sync
+      });
+      if (toolResult.error || toolResult.status !== 0) {
+        console.log(
+          chalk8.yellow(
+            "Tool sync incomplete - run `droid update --tools` to retry"
+          )
+        );
+      }
+    }
   } catch {
     console.log(chalk8.yellow("\n\u26A0 Could not check for updates"));
     console.log(chalk8.gray("Package may not be published yet."));
@@ -2413,7 +2694,8 @@ import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var PLATFORM_LABELS2 = {
   ["claude-code" /* ClaudeCode */]: "Claude Code",
   ["cursor" /* Cursor */]: "Cursor",
-  ["opencode" /* OpenCode */]: "OpenCode"
+  ["opencode" /* OpenCode */]: "OpenCode",
+  ["openai-codex" /* OpenAICodex */]: "OpenAI Codex"
 };
 function SettingsDetails({
   isFocused,
@@ -2510,7 +2792,8 @@ import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 var PLATFORM_INFO = {
   ["claude-code" /* ClaudeCode */]: { color: "#da7756", label: "Claude" },
   ["cursor" /* Cursor */]: { color: "#22d3ee", label: "Cursor" },
-  ["opencode" /* OpenCode */]: { color: "#4ade80", label: "OpenCode" }
+  ["opencode" /* OpenCode */]: { color: "#4ade80", label: "OpenCode" },
+  ["openai-codex" /* OpenAICodex */]: { color: "#10b981", label: "Codex" }
 };
 function PlatformBadges({
   detected,
@@ -2790,7 +3073,8 @@ import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 var PLATFORM_LABELS3 = {
   ["claude-code" /* ClaudeCode */]: "Claude Code",
   ["cursor" /* Cursor */]: "Cursor",
-  ["opencode" /* OpenCode */]: "OpenCode"
+  ["opencode" /* OpenCode */]: "OpenCode",
+  ["openai-codex" /* OpenAICodex */]: "Codex"
 };
 function SetupScreen({ onComplete, onSkip, initialConfig, detectedPlatforms }) {
   const [step, setStep] = useState3("user_mention");
@@ -2853,6 +3137,12 @@ function SetupScreen({ onComplete, onSkip, initialConfig, detectedPlatforms }) {
         for (const platform of detectedPlatforms) {
           configurePlatformPermissions(platform);
         }
+        if (detectedPlatforms.includes("openai-codex" /* OpenAICodex */)) {
+          const trackedTools = getPlatformTools(config);
+          for (const skillName of Object.keys(trackedTools)) {
+            createCodexSymlink(skillName);
+          }
+        }
         onComplete();
       }
     }
@@ -3088,8 +3378,8 @@ function ReadmeViewer({ title, content, onClose }) {
 // src/commands/tui/views/ToolExplorer.tsx
 import { Box as Box11, Text as Text12, useInput as useInput5 } from "ink";
 import { useState as useState5, useMemo as useMemo3 } from "react";
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
 import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
 function ToolExplorer({ tool, onViewSource, onClose }) {
   const [selectedIndex, setSelectedIndex] = useState5(0);
@@ -3100,7 +3390,7 @@ function ToolExplorer({ tool, onViewSource, onClose }) {
       result.push({
         type: "skill",
         name: skill.name,
-        path: join9(toolDir, tool.name, "skills", skill.name, "SKILL.md")
+        path: join10(toolDir, tool.name, "skills", skill.name, "SKILL.md")
       });
     }
     for (const cmd of tool.includes.commands) {
@@ -3108,14 +3398,14 @@ function ToolExplorer({ tool, onViewSource, onClose }) {
       result.push({
         type: "command",
         name: `/${cmdName}`,
-        path: join9(toolDir, tool.name, "commands", `${cmdName}.md`)
+        path: join10(toolDir, tool.name, "commands", `${cmdName}.md`)
       });
     }
     for (const agent of tool.includes.agents) {
       result.push({
         type: "agent",
         name: agent,
-        path: join9(toolDir, tool.name, "agents", agent, "AGENT.md")
+        path: join10(toolDir, tool.name, "agents", agent, "AGENT.md")
       });
     }
     return result;
@@ -3133,12 +3423,12 @@ function ToolExplorer({ tool, onViewSource, onClose }) {
     }
     if (key.return && items.length > 0) {
       const item = items[selectedIndex];
-      if (existsSync8(item.path)) {
+      if (existsSync9(item.path)) {
         const content = readFileSync8(item.path, "utf-8");
         onViewSource(`${tool.name} / ${item.name}`, content);
       } else {
         const yamlPath = item.path.replace(".md", ".yaml");
-        if (existsSync8(yamlPath)) {
+        if (existsSync9(yamlPath)) {
           const content = readFileSync8(yamlPath, "utf-8");
           onViewSource(`${tool.name} / ${item.name}`, content);
         }
@@ -3677,6 +3967,7 @@ function ReposViewerScreen({ onClose }) {
 // src/commands/tui/hooks/useAppUpdate.ts
 import { useState as useState8, useMemo as useMemo5 } from "react";
 import { useApp } from "ink";
+import { spawnSync as spawnSync2 } from "child_process";
 function useAppUpdate({ onUpdateSuccess, onUpdateFailure }) {
   const { exit } = useApp();
   const [isUpdating, setIsUpdating] = useState8(false);
@@ -3689,6 +3980,18 @@ function useAppUpdate({ onUpdateSuccess, onUpdateFailure }) {
         const blue = "\x1B[38;2;99;102;241m";
         const dim = "\x1B[38;2;106;106;106m";
         const reset = "\x1B[0m";
+        const autoUpdateConfig = getAutoUpdateConfig();
+        let toolStatus = `${blue}App updated.${reset}`;
+        if (autoUpdateConfig.tools) {
+          console.log("\nSyncing tools...");
+          const toolResult = spawnSync2("droid", ["update", "--tools"], {
+            stdio: "inherit",
+            timeout: 6e4
+            // 60s timeout for tool sync
+          });
+          const toolsSynced = !toolResult.error && toolResult.status === 0;
+          toolStatus = toolsSynced ? `${blue}App and tools updated.${reset}` : `${blue}App updated.${reset} Tools sync incomplete - run ${blue}droid update --tools${reset} to retry.`;
+        }
         const message = `
 ${dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${reset}
 
@@ -3696,6 +3999,7 @@ ${dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u
     ${dim}\u2551${reset} ${blue}\u25CF${reset} ${blue}\u25CF${reset} ${dim}\u2551${reset}   ${blue}"It's quite possible this system${reset}
     ${dim}\u255A\u2550\u2566\u2550\u2566\u2550\u255D${reset}    ${blue}is now fully operational."${reset}
 
+             ${toolStatus}
              Run ${blue}droid${reset} to start the new version.
 
 ${dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${reset}
@@ -4254,8 +4558,8 @@ async function tuiCommand() {
 // src/commands/exec.ts
 import chalk9 from "chalk";
 import { spawn } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join11 } from "path";
 function getRuntime(toolPath) {
   if (toolPath.endsWith(".ts") || toolPath.endsWith(".js")) {
     return { cmd: "bun", args: ["run", toolPath] };
@@ -4268,21 +4572,21 @@ function getRuntime(toolPath) {
 async function execCommand(tool, script, args) {
   const config = loadConfig();
   const skillsPath = getSkillsPath(config.platform);
-  const toolDir = join10(skillsPath, tool);
-  if (!existsSync9(toolDir)) {
+  const toolDir = join11(skillsPath, tool);
+  if (!existsSync10(toolDir)) {
     console.error(chalk9.red(`Tool '${tool}' not found at ${toolDir}`));
     process.exit(1);
   }
-  const scriptsDir = join10(toolDir, "scripts");
-  if (!existsSync9(scriptsDir)) {
+  const scriptsDir = join11(toolDir, "scripts");
+  if (!existsSync10(scriptsDir)) {
     console.error(chalk9.red(`No scripts directory in tool '${tool}'`));
     process.exit(1);
   }
   const extensions = [".ts", ".js", ".py"];
   let scriptPath = null;
   for (const ext of extensions) {
-    const candidate = join10(scriptsDir, script + ext);
-    if (existsSync9(candidate)) {
+    const candidate = join11(scriptsDir, script + ext);
+    if (existsSync10(candidate)) {
       scriptPath = candidate;
       break;
     }
@@ -4444,6 +4748,135 @@ async function reposGetCommand(name) {
   console.log(JSON.stringify(repo, null, 2));
 }
 
+// src/commands/auth.ts
+import inquirer5 from "inquirer";
+import chalk11 from "chalk";
+import { execSync as execSync6 } from "child_process";
+
+// src/lib/secrets.ts
+function hasSlackToken() {
+  return !!process.env.SLACK_USER_TOKEN;
+}
+
+// src/commands/auth.ts
+var SLACK_SCOPES = "chat:write,canvases:write";
+var REDIRECT_URI = "https://localhost:9876/callback";
+function getShellConfig() {
+  const shell = process.env.SHELL || "/bin/zsh";
+  if (shell.includes("zsh")) return "~/.zshrc";
+  if (shell.includes("bash")) return "~/.bashrc";
+  if (shell.includes("fish")) return "~/.config/fish/config.fish";
+  return "~/.profile";
+}
+async function authSlackCommand() {
+  console.log(chalk11.bold("\n\u{1F510} Slack Authentication Setup\n"));
+  if (hasSlackToken()) {
+    console.log(chalk11.green("\u2713 SLACK_USER_TOKEN is already set in your environment\n"));
+    const { reauth } = await inquirer5.prompt([
+      {
+        type: "confirm",
+        name: "reauth",
+        message: "Re-authenticate anyway?",
+        default: false
+      }
+    ]);
+    if (!reauth) {
+      return;
+    }
+    console.log("");
+  }
+  const clientId = process.env.SLACK_CLIENT_ID;
+  const clientSecret = process.env.SLACK_CLIENT_SECRET;
+  if (!clientId || !clientSecret) {
+    const shellConfig = getShellConfig();
+    console.log(chalk11.yellow("Missing Slack app credentials.\n"));
+    console.log(chalk11.gray('Get Client ID and Client Secret from 1Password ("Droid Slack App")'));
+    console.log(chalk11.gray(`and add to your ${shellConfig}:
+`));
+    console.log(chalk11.white('  export SLACK_CLIENT_ID="your-client-id"'));
+    console.log(chalk11.white('  export SLACK_CLIENT_SECRET="your-client-secret"\n'));
+    console.log(chalk11.gray("Then reload and run this again:\n"));
+    console.log(chalk11.white(`  source ${shellConfig} && droid auth slack
+`));
+    return;
+  }
+  const authorizeUrl = `https://slack.com/oauth/v2/authorize?client_id=${clientId}&user_scope=${SLACK_SCOPES}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}`;
+  console.log(chalk11.yellow("Step 1: Authorize in Slack\n"));
+  console.log(chalk11.gray('  Go to the "Droid Setup" canvas in #rnd-updates and click "Install Droid Slack App"'));
+  console.log(chalk11.gray("  Or open this URL:\n"));
+  console.log(chalk11.cyan(`  ${authorizeUrl}
+`));
+  console.log(chalk11.gray("  After clicking Allow, you'll be redirected to a URL that won't load."));
+  console.log(chalk11.gray('  Copy the "code" parameter from the URL bar.\n'));
+  const { code } = await inquirer5.prompt([
+    {
+      type: "input",
+      name: "code",
+      message: "Paste the code:",
+      validate: (input) => input.length > 0 || "Code is required"
+    }
+  ]);
+  console.log(chalk11.yellow("\nStep 2: Exchanging code for token...\n"));
+  try {
+    const response = execSync6(
+      `curl -s -X POST https://slack.com/api/oauth.v2.access         -d "client_id=${clientId}"         -d "client_secret=${clientSecret}"         -d "code=${code}"         -d "redirect_uri=${REDIRECT_URI}"`,
+      { encoding: "utf-8" }
+    );
+    const result = JSON.parse(response);
+    if (!result.ok) {
+      console.log(chalk11.red(`\u2717 Slack API error: ${result.error}`));
+      if (result.error === "invalid_code") {
+        console.log(chalk11.gray("  The code may have expired. Try again with a fresh code."));
+      }
+      return;
+    }
+    const token = result.authed_user?.access_token;
+    if (!token) {
+      console.log(chalk11.red("\u2717 No user token in response"));
+      console.log(chalk11.gray("  Response:"), JSON.stringify(result, null, 2));
+      return;
+    }
+    const shellConfig = getShellConfig();
+    console.log(chalk11.green("\u2713 Got token!\n"));
+    console.log(chalk11.yellow("Step 3: Save the token\n"));
+    console.log(chalk11.gray(`  Add to your ${shellConfig}:
+`));
+    console.log(chalk11.white(`  export SLACK_USER_TOKEN="${token}"
+`));
+    console.log(chalk11.gray("  Then reload your shell:\n"));
+    console.log(chalk11.white(`  source ${shellConfig}
+`));
+  } catch (error) {
+    console.log(chalk11.red("\u2717 Failed to exchange code for token"));
+    if (error instanceof Error) {
+      console.log(chalk11.gray(`  ${error.message}`));
+    }
+  }
+}
+async function authStatusCommand() {
+  console.log(chalk11.bold("\n\u{1F510} Auth Status\n"));
+  const clientId = process.env.SLACK_CLIENT_ID;
+  const clientSecret = process.env.SLACK_CLIENT_SECRET;
+  const hasCredentials = clientId && clientSecret;
+  if (hasCredentials) {
+    console.log(chalk11.green("\u2713 Slack app credentials configured"));
+  } else {
+    console.log(chalk11.yellow("\u2717 Slack app credentials missing"));
+    console.log(chalk11.gray("  Run: droid auth slack"));
+  }
+  if (hasSlackToken()) {
+    const token = process.env.SLACK_USER_TOKEN;
+    const masked = token.slice(0, 10) + "..." + token.slice(-4);
+    console.log(chalk11.green("\u2713 Slack user token configured"));
+    console.log(chalk11.gray(`  Token: ${masked}`));
+  } else {
+    console.log(chalk11.yellow("\u2717 Slack user token missing"));
+    if (hasCredentials) {
+      console.log(chalk11.gray("  Run: droid auth slack"));
+    }
+  }
+}
+
 // src/bin/droid.ts
 var version = getVersion();
 program.name("droid").description("Droid, teaching your AI new tricks").version(version);
@@ -4463,6 +4896,19 @@ program.command("uninstall <tool>").description("Uninstall a tool").action(unins
 program.command("update").description("Update droid and installed tools").option("--tools", "Only update tools").option("--cli", "Only update the CLI").argument("[tool]", "Update a specific tool").action(updateCommand);
 program.command("tui").description("Launch interactive TUI dashboard").action(tuiCommand);
 program.command("exec <tool> <script>").description("Execute a tool script").argument("[args...]", "Arguments to pass to the script").allowUnknownOption().action(execCommand);
+var auth = program.command("auth").description("Set up authentication for external services");
+auth.command("slack").description("Set up Slack authentication for status updates").action(authSlackCommand);
+auth.command("status").description("Show authentication status").action(authStatusCommand);
+auth.action(authStatusCommand);
+if (configExists()) {
+  const config = loadConfig();
+  const newPlatforms = syncNewPlatforms(config);
+  if (newPlatforms.length > 0) {
+    console.log(chalk12.green(`\u2713 Detected new platform(s): ${newPlatforms.join(", ")}`));
+    console.log(chalk12.gray("  Synced installed tools to new platform(s)\n"));
+    saveConfig(config);
+  }
+}
 if (process.argv.length === 2) {
   tuiCommand();
 } else {