@orderful/droid 0.36.0 → 0.38.0

package/dist/tools/tech-design/skills/tech-design/references/start.md

@@ -50,14 +50,40 @@ The codex skill will:
   - UI/UX considerations (from DESIGN.md if present)
   - Key constraints or requirements
 
-### 3. Create Research Doc via Brain Skill
-
-Use the brain skill to create a research document:
+### 3. Create Unified Tech Design Folder
+
+Create a single folder to hold all tech design artifacts:
+
+```bash
+# Get brain config
+brain_config=$(droid config --get tools.brain)
+brain_dir=$(echo "$brain_config" | grep -o '"brain_dir": *"[^"]*"' | cut -d'"' -f4)
+inbox_folder=$(echo "$brain_config" | grep -o '"inbox_folder": *"[^"]*"' | cut -d'"' -f4)
+
+# Determine base path
+if [ -n "$inbox_folder" ]; then
+  base_path="$inbox_folder"
+else
+  base_path="$brain_dir"
+fi
+
+# Create folder structure
+design_folder="$base_path/tech-designs/{project}"
+mkdir -p "$design_folder"
+```
 
+**Folder structure:**
 ```
-/brain research tech-design-{project}-research
+{brain_dir}/{inbox?}/tech-designs/{project}/
+├── research.md
+├── thought-doc.md
+└── [diagrams, artifacts as needed]
 ```
 
+### 4. Create Research Doc
+
+Create `research.md` in the design folder:
+
 **Research doc template:**
 
 ```markdown
@@ -81,7 +107,7 @@ Research for tech design: {brief description from PRD}
 
 ## Codebase Discoveries
 
-{This section populated in step 4}
+{This section populated in step 5}
 
 ## Key Findings
 
@@ -174,13 +200,9 @@ Update the "Codebase Discoveries" section with specific discoveries:
 - Testing: {e.g., unit test setup, integration test patterns}
 ```
 
-### 5. Create Thought Doc via Brain Skill
-
-Use the brain skill to create the planning document:
+### 5. Create Thought Doc
 
-```
-/brain plan tech-design-{project}
-```
+Create `thought-doc.md` in the same folder:
 
 **Thought doc template:**
 
@@ -191,7 +213,7 @@ Use the brain skill to create the planning document:
 **Status:** exploring
 **Created:** {current date}
 **PRD:** [[codex:projects/{project}/PRD]]
-**Research:** [[tech-design-{project}-research]]
+**Research:** [[research|Research doc in same folder]]
 
 Tech design for {project}.
 
@@ -203,7 +225,7 @@ Tech design for {project}.
 - Who it's for and why it matters
 - Key constraints or requirements
 
-See research doc for codebase context and discovered patterns.
+See research.md for codebase context and discovered patterns.
 
 ## Proposal
 
@@ -214,15 +236,18 @@ See research doc for codebase context and discovered patterns.
 {What we don't know yet - to be explored}
 ```
 
-Set thought doc as active in brain's session tracking.
+Set thought-doc.md path for session tracking (active design).
 
 ### 6. Provide Links to User
 
-After creating both docs, give the user the file paths:
+After creating both docs, give the user the folder path:
 
 ```
-✓ Research doc created: {full_path_to_research_doc}
-✓ Tech design created: {full_path_to_thought_doc}
+✓ Tech design folder created: {design_folder}/
+
+Files:
+  • research.md - Codex context and codebase discoveries
+  • thought-doc.md - Design iteration workspace (active)
 
 Research doc includes:
   • Codex project context from {project}
@@ -230,6 +255,7 @@ Research doc includes:
   • Technical stack notes
 
 You can continue working on this with:
+  • /tech-design search {project} - Resume this design later
   • /tech-design draft - Auto-generate sections from research
   • /tech-design think {topic} - Explore specific ideas
   • /brain add {text} - Quick additions to active doc
@@ -243,7 +269,7 @@ What would you like to do next?
 - **Brain not configured:** "Brain skill not configured. Please run `/brain` to set up your brain directory first."
 - **Codex not configured:** "Codex skill not configured. Please run `/codex` to set up your codex repository first."
 - **PRD missing:** Offer to create via `/codex new {project}` or continue without context
-- **Docs already exist:** "Tech design docs for '{project}' already exist. Open existing or create new?"
+- **Folder already exists:** "Tech design for '{project}' already exists at {path}. Resume with `/tech-design search {project}` or create with different name?"
 - **Codebase exploration fails:** Gracefully note what couldn't be found, continue with what's available
 
 ## Example Output
@@ -257,8 +283,11 @@ Research findings:
   🔗 Identified 5 integration points (validation, storage, API)
   📦 Dependencies: 2 already available, 1 to add
 
-✓ Research doc created: {brain_dir}/0-Inbox/research/tech-design-transaction-templates-research.md
-✓ Tech design created: {brain_dir}/0-Inbox/plans/tech-design-transaction-templates.md
+✓ Tech design folder created: {brain_dir}/0-Inbox/tech-designs/transaction-templates/
+
+Files:
+  • research.md - Codex context and codebase discoveries
+  • thought-doc.md - Design iteration workspace (active)
 
 Research doc includes:
   • Codex project context from transaction-templates
@@ -266,6 +295,7 @@ Research doc includes:
   • Technical stack notes
 
 You can continue working on this with:
+  • /tech-design search transaction-templates - Resume this design later
   • /tech-design draft - Auto-generate sections from research
   • /tech-design think {topic} - Explore specific ideas
   • /brain add {text} - Quick additions to active doc

package/dist/tools/wrapup/.claude-plugin/plugin.json

@@ -12,5 +12,11 @@
     "droid",
     "ai",
     "wrapup"
+  ],
+  "skills": [
+    "./skills/wrapup/SKILL.md"
+  ],
+  "commands": [
+    "./commands/wrapup.md"
   ]
 }

package/dist/tools/wrapup/skills/wrapup/SKILL.md

@@ -18,6 +18,8 @@ Wrapup has no configuration of its own. It reads config from other installed too
 
 If these tools aren't configured, wrapup skips those artifacts and focuses on git state and conversation summary.
 
+**Overrides:** This skill supports user-defined overrides. See `/droid` skill § Skill Overrides.
+
 ## Context Lifeboat Pattern
 
 This skill runs at the END of sessions when context pressure is highest.

package/package.json

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

package/scripts/build-plugins.ts

@@ -15,9 +15,14 @@
  */
 
 import { mkdirSync, writeFileSync, existsSync, readdirSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { join, basename } from 'path';
 import { parse as parseYaml } from 'yaml';
 
+interface CommandInclude {
+  name: string;
+  is_alias?: boolean;
+}
+
 interface ToolManifest {
   name: string;
   description: string;
@@ -26,7 +31,7 @@ interface ToolManifest {
   system?: boolean;
   includes: {
     skills: Array<{ name: string; required: boolean; description?: string }>;
-    commands: string[];
+    commands: CommandInclude[];
     agents: string[];
   };
   dependencies?: string[];
@@ -44,6 +49,9 @@ interface PluginJson {
   repository?: string;
   license?: string;
   keywords?: string[];
+  skills?: string[];
+  commands?: string[];
+  agents?: string[];
 }
 
 interface MarketplacePlugin {
@@ -111,11 +119,122 @@ function getToolDirs(): string[] {
   return entries
     .filter((e) => e.isDirectory())
     .map((e) => join(TOOLS_DIR, e.name))
-    .filter((dir) => existsSync(join(dir, 'TOOL.yaml')));
+    .filter((dir) => existsSync(join(dir, 'TOOL.yaml')))
+    .sort(); // Ensure deterministic order across platforms
+}
+
+/**
+ * Get relative paths to skill files for plugin.json.
+ * Paths are relative to the tool's .claude-plugin directory.
+ */
+function getSkillPaths(manifest: ToolManifest): string[] {
+  const skills = manifest.includes.skills ?? [];
+  return skills.map((skill) => `./skills/${skill.name}/SKILL.md`);
+}
+
+/**
+ * Get relative paths to command files for plugin.json.
+ * Excludes alias commands since they're just pointers to the main command.
+ */
+function getCommandPaths(manifest: ToolManifest): string[] {
+  const commands = manifest.includes.commands ?? [];
+  return commands
+    .filter((cmd) => !cmd.is_alias)
+    .map((cmd) => `./commands/${cmd.name}.md`);
+}
+
+/**
+ * Get relative paths to agent files for plugin.json.
+ */
+function getAgentPaths(manifest: ToolManifest): string[] {
+  const agents = manifest.includes.agents ?? [];
+  return agents.map((agent) => `./agents/${agent}.md`);
+}
+
+/**
+ * Get repo-root-relative paths to skill files for combined plugin.json.
+ */
+function getSkillPathsFromRoot(manifest: ToolManifest, toolDir: string): string[] {
+  const skills = manifest.includes.skills ?? [];
+  return skills.map((skill) => `./${toolDir}/skills/${skill.name}/SKILL.md`);
+}
+
+/**
+ * Get repo-root-relative paths to command files for combined plugin.json.
+ * Excludes alias commands since they're just pointers to the main command.
+ */
+function getCommandPathsFromRoot(manifest: ToolManifest, toolDir: string): string[] {
+  const commands = manifest.includes.commands ?? [];
+  return commands
+    .filter((cmd) => !cmd.is_alias)
+    .map((cmd) => `./${toolDir}/commands/${cmd.name}.md`);
+}
+
+/**
+ * Get repo-root-relative paths to agent files for combined plugin.json.
+ */
+function getAgentPathsFromRoot(manifest: ToolManifest, toolDir: string): string[] {
+  const agents = manifest.includes.agents ?? [];
+  return agents.map((agent) => `./${toolDir}/agents/${agent}.md`);
+}
+
+/**
+ * Get the droid tool version for the combined plugin.json.
+ */
+function getDroidVersion(toolDirs: string[]): string {
+  const droidDir = toolDirs.find((dir) => basename(dir) === 'droid');
+  if (droidDir) {
+    const manifest = loadToolManifest(droidDir);
+    if (manifest) return manifest.version;
+  }
+  return '0.0.0';
+}
+
+/**
+ * Build combined plugin.json at repo root for marketplace installations.
+ * Aggregates all tools' content with repo-root-relative paths.
+ */
+function buildCombinedPlugin(toolDirs: string[]): void {
+  const allSkills: string[] = [];
+  const allCommands: string[] = [];
+  const allAgents: string[] = [];
+
+  for (const toolDir of toolDirs) {
+    const manifest = loadToolManifest(toolDir);
+    if (!manifest) continue;
+
+    allSkills.push(...getSkillPathsFromRoot(manifest, toolDir));
+    allCommands.push(...getCommandPathsFromRoot(manifest, toolDir));
+    allAgents.push(...getAgentPathsFromRoot(manifest, toolDir));
+  }
+
+  // Ensure directory exists
+  const marketplaceDir = '.claude-plugin';
+  mkdirSync(marketplaceDir, { recursive: true });
+
+  const combinedPlugin: PluginJson = {
+    name: 'droid',
+    version: getDroidVersion(toolDirs),
+    description: 'AI-powered development tools for Claude Code',
+    author: AUTHOR,
+    repository: REPO,
+    license: 'MIT',
+    keywords: ['droid', 'ai', 'tools'],
+  };
+
+  if (allSkills.length > 0) combinedPlugin.skills = allSkills;
+  if (allCommands.length > 0) combinedPlugin.commands = allCommands;
+  if (allAgents.length > 0) combinedPlugin.agents = allAgents;
+
+  writeFileSync(
+    join(marketplaceDir, 'plugin.json'),
+    JSON.stringify(combinedPlugin, null, 2) + '\n'
+  );
+  console.log(`Combined plugin.json created at .claude-plugin/plugin.json`);
 }
 
 function createPluginJson(manifest: ToolManifest, pluginName: string): PluginJson {
-  return {
+  const json: PluginJson = {
     name: pluginName,
     version: manifest.version,
     description: manifest.description,
@@ -124,6 +243,26 @@ function createPluginJson(manifest: ToolManifest, pluginName: string): PluginJso
     license: 'MIT',
     keywords: [...new Set(['droid', 'ai', manifest.name])],
   };
+
+  // Add skills if present
+  const skills = getSkillPaths(manifest);
+  if (skills.length > 0) {
+    json.skills = skills;
+  }
+
+  // Add commands if present
+  const commands = getCommandPaths(manifest);
+  if (commands.length > 0) {
+    json.commands = commands;
+  }
+
+  // Add agents if present
+  const agents = getAgentPaths(manifest);
+  if (agents.length > 0) {
+    json.agents = agents;
+  }
+
+  return json;
 }
 
 function buildPluginManifest(toolDir: string): MarketplacePlugin | null {
@@ -165,15 +304,21 @@ function buildMarketplace(plugins: MarketplacePlugin[]): void {
   const marketplaceDir = '.claude-plugin';
   mkdirSync(marketplaceDir, { recursive: true });
 
+  // Only advertise "droid" in marketplace - Claude Code ignores the path field
+  // and always reads from repo root, so per-tool entries would fail with name
+  // mismatch errors. Users install "droid" to get all tools.
+  // Per-tool plugin.json files still exist for direct installs via --path.
+  const marketplacePlugins = plugins.filter((p) => p.name === 'droid');
+
   const marketplace: MarketplaceJson = {
     name: 'droid',
     description: 'AI-powered development tools for Claude Code',
     owner: AUTHOR,
-    plugins: plugins.sort((a, b) => a.name.localeCompare(b.name)),
+    plugins: marketplacePlugins,
   };
 
   writeFileSync(join(marketplaceDir, 'marketplace.json'), JSON.stringify(marketplace, null, 2) + '\n');
-  console.log(`\nMarketplace manifest created at .claude-plugin/marketplace.json with ${plugins.length} plugins`);
+  console.log(`\nMarketplace manifest created at .claude-plugin/marketplace.json with ${marketplacePlugins.length} plugin(s)`);
 }
 
 function main(): void {
@@ -193,6 +338,9 @@ function main(): void {
   // Build marketplace manifest
   buildMarketplace(plugins);
 
+  // Build combined plugin.json for marketplace installations
+  buildCombinedPlugin(toolDirs);
+
   console.log('\nPlugin manifest generation complete!');
   console.log(`\nTo test locally:`);
   console.log(`  /plugin marketplace add ${process.cwd()}`);

package/src/bin/droid.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { program } from 'commander';
+import chalk from 'chalk';
 import { setupCommand } from '../commands/setup';
 import { configCommand } from '../commands/config';
 import { skillsCommand } from '../commands/skills';
@@ -16,6 +17,8 @@ import {
   reposGetCommand,
 } from '../commands/repos';
 import { getVersion } from '../lib/version';
+import { loadConfig, saveConfig, configExists } from '../lib/config';
+import { syncNewPlatforms } from '../lib/platforms';
 
 const version = getVersion();
 
@@ -106,6 +109,19 @@ program
   .allowUnknownOption()
   .action(execCommand);
 
+// Sync new platforms before running any command
+// This ensures that newly installed platforms (e.g., Codex) get all existing tools
+if (configExists()) {
+  const config = loadConfig();
+  const newPlatforms = syncNewPlatforms(config);
+
+  if (newPlatforms.length > 0) {
+    console.log(chalk.green(`✓ Detected new platform(s): ${newPlatforms.join(', ')}`));
+    console.log(chalk.gray('  Synced installed tools to new platform(s)\n'));
+    saveConfig(config);
+  }
+}
+
 // If no command provided, launch TUI
 if (process.argv.length === 2) {
   tuiCommand();

package/src/commands/setup.ts

@@ -4,10 +4,11 @@ import { execSync } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { loadConfig, saveConfig, configExists } from '../lib/config';
+import { loadConfig, saveConfig, configExists, getConfigDir } from '../lib/config';
 import { getBundledSkills } from '../lib/skills';
 import { Platform, BuiltInOutput, type DroidConfig, type OutputPreference } from '../lib/types';
-import { detectAllPlatforms } from '../lib/platforms';
+import { detectAllPlatforms, createCodexSymlink } from '../lib/platforms';
+import { getPlatformTools } from '../lib/types';
 
 // Re-export for external use
 export { detectAllPlatforms, getActivePlatforms } from '../lib/platforms';
@@ -16,6 +17,7 @@ const PLATFORM_LABELS: Record<Platform, string> = {
   [Platform.ClaudeCode]: 'Claude Code',
   [Platform.Cursor]: 'Cursor',
   [Platform.OpenCode]: 'OpenCode',
+  [Platform.OpenAICodex]: 'Codex',
 };
 
 /**
@@ -29,6 +31,89 @@ const DROID_PERMISSIONS = [
   'Grep(~/.droid/**)',
 ];
 
+/**
+ * Template content for skill overrides
+ */
+const 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
+`;
+
+/**
+ * Create skill_overrides directory with template
+ */
+function createSkillOverridesDir(): { created: boolean; alreadyExists: boolean } {
+  const overridesDir = join(getConfigDir(), 'skill_overrides');
+  const templatePath = join(overridesDir, '_template.md');
+
+  // Check if directory already exists with template
+  if (existsSync(templatePath)) {
+    return { created: false, alreadyExists: true };
+  }
+
+  // Create directory if needed
+  if (!existsSync(overridesDir)) {
+    mkdirSync(overridesDir, { recursive: true });
+  }
+
+  // Write template
+  writeFileSync(templatePath, SKILL_OVERRIDES_TEMPLATE, 'utf-8');
+  return { created: true, alreadyExists: false };
+}
+
 /**
  * Try to get git username
  */
@@ -261,6 +346,14 @@ export async function setupCommand(): Promise<void> {
 
   console.log(chalk.green('\n✓ Config saved to ~/.droid/config.yaml'));
 
+  // Create skill_overrides directory with template
+  const { created: overridesCreated, alreadyExists: overridesExist } = createSkillOverridesDir();
+  if (overridesCreated) {
+    console.log(chalk.green('✓ Created ~/.droid/skill_overrides/ with template'));
+  } else if (overridesExist) {
+    console.log(chalk.gray('  Skill overrides directory already exists'));
+  }
+
   // Configure permissions for ALL active platforms
   for (const platform of activePlatforms) {
     const { added, alreadyPresent, error } = configurePlatformPermissions(platform);
@@ -277,6 +370,18 @@ export async function setupCommand(): Promise<void> {
     }
   }
 
+  // Create Codex symlinks for tracked tools only (not all skills in directory)
+  if (activePlatforms.includes(Platform.OpenAICodex)) {
+    const trackedTools = getPlatformTools(config);
+    const toolNames = Object.keys(trackedTools);
+    if (toolNames.length > 0) {
+      for (const skillName of toolNames) {
+        createCodexSymlink(skillName);
+      }
+      console.log(chalk.green('✓ Created Codex symlinks for installed tools'));
+    }
+  }
+
   // Show summary if multiple platforms
   if (activePlatforms.length > 1) {
     console.log(chalk.green(`\n✓ Will install to ${activePlatforms.length} platforms: ${activePlatforms.map(p => PLATFORM_LABELS[p]).join(', ')}`));

package/src/commands/tui/components/PlatformBadges.tsx

@@ -5,6 +5,7 @@ const PLATFORM_INFO: Record<Platform, { color: string; label: string }> = {
   [Platform.ClaudeCode]: { color: '#da7756', label: 'Claude' },
   [Platform.Cursor]: { color: '#22d3ee', label: 'Cursor' },
   [Platform.OpenCode]: { color: '#4ade80', label: 'OpenCode' },
+  [Platform.OpenAICodex]: { color: '#10b981', label: 'Codex' },
 };
 
 export function PlatformBadges({

package/src/commands/tui/components/SettingsDetails.tsx

@@ -14,6 +14,7 @@ const PLATFORM_LABELS: Record<Platform, string> = {
   [Platform.ClaudeCode]: 'Claude Code',
   [Platform.Cursor]: 'Cursor',
   [Platform.OpenCode]: 'OpenCode',
+  [Platform.OpenAICodex]: 'OpenAI Codex',
 };
 
 export function SettingsDetails({

package/src/commands/tui/hooks/useAppUpdate.ts

@@ -1,7 +1,8 @@
 import { useState, useMemo } from 'react';
 import { useApp } from 'ink';
+import { spawnSync } from 'child_process';
 import { getUpdateInfo, runUpdate, type UpdateInfo } from '../../../lib/version';
-import { setAutoUpdateConfig } from '../../../lib/config';
+import { setAutoUpdateConfig, getAutoUpdateConfig } from '../../../lib/config';
 
 export interface UseAppUpdateOptions {
   onUpdateSuccess: (message: string) => void;
@@ -31,6 +32,24 @@ export function useAppUpdate({ onUpdateSuccess, onUpdateFailure }: UseAppUpdateO
         const blue = '\x1b[38;2;99;102;241m'; // #6366f1
         const dim = '\x1b[38;2;106;106;106m';
         const reset = '\x1b[0m';
+
+        // Check if auto-update tools is enabled
+        const autoUpdateConfig = getAutoUpdateConfig();
+        let toolStatus = `${blue}App updated.${reset}`;
+
+        if (autoUpdateConfig.tools) {
+          // Spawn NEW binary to sync tools (has new bundled manifests)
+          console.log('\nSyncing tools...');
+          const toolResult = spawnSync('droid', ['update', '--tools'], {
+            stdio: 'inherit',
+            timeout: 60000, // 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}────────────────────────────────────────────────────────${reset}
 
@@ -38,6 +57,7 @@ ${dim}────────────────────────
     ${dim}║${reset} ${blue}●${reset} ${blue}●${reset} ${dim}║${reset}   ${blue}"It's quite possible this system${reset}
     ${dim}╚═╦═╦═╝${reset}    ${blue}is now fully operational."${reset}
 
+             ${toolStatus}
              Run ${blue}droid${reset} to start the new version.
 
 ${dim}────────────────────────────────────────────────────────${reset}

package/src/commands/tui/views/SetupScreen.tsx

@@ -3,9 +3,10 @@ import TextInput from 'ink-text-input';
 import { useState } from 'react';
 import { colors } from '../constants';
 import type { SetupStep } from '../types';
-import { Platform, BuiltInOutput, type DroidConfig } from '../../../lib/types';
+import { Platform, BuiltInOutput, type DroidConfig, getPlatformTools } from '../../../lib/types';
 import { loadConfig, saveConfig, getAutoUpdateConfig, setAutoUpdateConfig } from '../../../lib/config';
 import { configurePlatformPermissions } from '../../setup';
+import { createCodexSymlink } from '../../../lib/platforms';
 
 export interface SetupScreenProps {
   onComplete: () => void;
@@ -18,6 +19,7 @@ const PLATFORM_LABELS: Record<Platform, string> = {
   [Platform.ClaudeCode]: 'Claude Code',
   [Platform.Cursor]: 'Cursor',
   [Platform.OpenCode]: 'OpenCode',
+  [Platform.OpenAICodex]: 'Codex',
 };
 
 export function SetupScreen({ onComplete, onSkip, initialConfig, detectedPlatforms }: SetupScreenProps) {
@@ -94,6 +96,13 @@ export function SetupScreen({ onComplete, onSkip, initialConfig, detectedPlatfor
         for (const platform of detectedPlatforms) {
           configurePlatformPermissions(platform);
         }
+        // Create Codex symlinks for tracked tools only (not all skills in directory)
+        if (detectedPlatforms.includes(Platform.OpenAICodex)) {
+          const trackedTools = getPlatformTools(config);
+          for (const skillName of Object.keys(trackedTools)) {
+            createCodexSymlink(skillName);
+          }
+        }
         onComplete();
       }
     }