feat: auto-discover skills/commands from Claude Code, Codex, and Gemini configs

Adds external skill discovery with both auto and manual modes:

Auto mode (opt-in):
  Set experimental.auto_skill_discovery: true in config to auto-load
  external skills at startup.

Manual mode (always available):
  Run /discover-skills to scan, list, and selectively add skills on
  demand — works regardless of config setting. Uses the skill_discover
  tool which directly registers skills into runtime state (no config
  flag dependency).

Sources scanned:
  - .claude/commands/**/*.md (Claude Code commands)
  - .codex/skills/**/SKILL.md (Codex CLI skills)
  - .gemini/skills/**/SKILL.md (Gemini CLI skills)
  - .gemini/commands/**/*.toml (Gemini commands, {{args}} → $ARGUMENTS)

Security:
  - Rejects symlinks (lstat check)
  - Rejects __proto__/constructor/prototype names
  - Rejects path traversal (.. in names)
  - Existing skills never overwritten

Tests: 21 unit tests + 1 sanity resilience test

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kulvirgit

packages/opencode/src/altimate/tools/skill-discover.ts

@@ -0,0 +1,115 @@
+// altimate_change start — skill discovery tool for on-demand external skill scanning
+import z from "zod"
+import path from "path"
+import { Tool } from "../../tool/tool"
+import { discoverExternalSkills } from "../../skill/discover-external"
+import { Instance } from "../../project/instance"
+import { Skill } from "../../skill/skill"
+
+export const SkillDiscoverTool = Tool.define("skill_discover", {
+  description:
+    "Discover skills and commands from external AI tool configs (Claude Code, Codex CLI, Gemini CLI). Lists what's available and which are already loaded.",
+  parameters: z.object({
+    action: z
+      .enum(["list", "add"])
+      .describe('"list" to show discovered skills, "add" to load them into the current session'),
+    skills: z
+      .array(z.string())
+      .optional()
+      .describe('When action is "add", which skills to load. Omit to add all discovered skills.'),
+  }),
+  async execute(args) {
+    const { skills: discovered, sources } = await discoverExternalSkills(Instance.worktree)
+
+    if (discovered.length === 0) {
+      return {
+        title: "Skill Discovery",
+        metadata: { action: args.action, found: 0 },
+        output:
+          "No external skills or commands found.\n\n" +
+          "Searched for:\n" +
+          "- .claude/commands/**/*.md (Claude Code commands)\n" +
+          "- .codex/skills/**/SKILL.md (Codex CLI skills)\n" +
+          "- .gemini/skills/**/SKILL.md (Gemini CLI skills)\n" +
+          "- .gemini/commands/**/*.toml (Gemini CLI commands)\n\n" +
+          "These are searched in both the project directory and home directory.",
+      }
+    }
+
+    // Get currently loaded skills to show which are new
+    const existing = await Skill.all()
+    const existingNames = new Set(existing.map((s) => s.name))
+
+    const newSkills = discovered.filter((s) => !existingNames.has(s.name))
+    const alreadyLoaded = discovered.filter((s) => existingNames.has(s.name))
+
+    if (args.action === "list") {
+      const lines: string[] = [
+        `Found ${discovered.length} external skill(s) from ${sources.join(", ")}:`,
+        "",
+      ]
+
+      if (newSkills.length > 0) {
+        lines.push(`**New** (${newSkills.length}):`)
+        for (const s of newSkills) {
+          lines.push(`- \`${s.name}\` — ${s.description || "(no description)"} (${s.location})`)
+        }
+        lines.push("")
+      }
+
+      if (alreadyLoaded.length > 0) {
+        lines.push(`**Already loaded** (${alreadyLoaded.length}):`)
+        for (const s of alreadyLoaded) {
+          lines.push(`- \`${s.name}\``)
+        }
+        lines.push("")
+      }
+
+      if (newSkills.length > 0) {
+        lines.push(
+          'To add these skills to the current session, call this tool again with `action: "add"`.',
+        )
+      }
+
+      return {
+        title: `Skill Discovery: ${discovered.length} found (${newSkills.length} new)`,
+        metadata: { action: "list", found: discovered.length, new: newSkills.length },
+        output: lines.join("\n"),
+      }
+    }
+
+    // action === "add"
+    const toAdd = args.skills
+      ? discovered.filter((s) => args.skills!.includes(s.name) && !existingNames.has(s.name))
+      : newSkills
+
+    if (toAdd.length === 0) {
+      return {
+        title: "Skill Discovery: nothing to add",
+        metadata: { action: "add", added: 0 },
+        output: "All discovered skills are already loaded in the current session.",
+      }
+    }
+
+    // Directly register skills into the runtime state — works regardless of
+    // auto_skill_discovery config setting. This is the on-demand path.
+    const currentState = await Skill.state()
+    for (const skill of toAdd) {
+      if (!currentState.skills[skill.name]) {
+        currentState.skills[skill.name] = skill
+        currentState.dirs.push(path.dirname(skill.location))
+      }
+    }
+
+    return {
+      title: `Skill Discovery: ${toAdd.length} skill(s) added`,
+      metadata: { action: "add", added: toAdd.length, names: toAdd.map((s) => s.name) },
+      output:
+        `Added ${toAdd.length} skill(s) to the current session:\n` +
+        toAdd.map((s) => `- \`/${s.name}\` — ${s.description || "(no description)"}`).join("\n") +
+        "\n\nTo enable auto-discovery at startup, set `experimental.auto_skill_discovery: true` in your config." +
+        "\n\nYou can now use these skills by name (e.g., `/" + toAdd[0].name + "`).",
+    }
+  },
+})
+// altimate_change end

packages/opencode/src/command/index.ts

@@ -12,6 +12,7 @@ import PROMPT_FEEDBACK from "./template/feedback.txt"
 import PROMPT_CONFIGURE_CLAUDE from "./template/configure-claude.txt"
 import PROMPT_CONFIGURE_CODEX from "./template/configure-codex.txt"
 import PROMPT_DISCOVER_MCPS from "./template/discover-and-add-mcps.txt"
+import PROMPT_DISCOVER_SKILLS from "./template/discover-skills.txt"
 // altimate_change end
 import { MCP } from "../mcp"
 import { Skill } from "../skill"
@@ -72,6 +73,7 @@ export namespace Command {
     CONFIGURE_CLAUDE: "configure-claude",
     CONFIGURE_CODEX: "configure-codex",
     DISCOVER_MCPS: "discover-and-add-mcps",
+    DISCOVER_SKILLS: "discover-skills",
     // altimate_change end
   } as const
 
@@ -144,6 +146,15 @@ export namespace Command {
         },
         hints: hints(PROMPT_DISCOVER_MCPS),
       },
+      [Default.DISCOVER_SKILLS]: {
+        name: Default.DISCOVER_SKILLS,
+        description: "discover skills/commands from Claude Code, Codex, and Gemini configs",
+        source: "command",
+        get template() {
+          return PROMPT_DISCOVER_SKILLS
+        },
+        hints: hints(PROMPT_DISCOVER_SKILLS),
+      },
       // altimate_change end
     }
 
@@ -206,7 +217,7 @@ export namespace Command {
           get template() {
             return skill.content
           },
-          hints: [],
+          hints: hints(skill.content),
         }
       }
     } catch (e) {

packages/opencode/src/command/template/discover-skills.txt

@@ -0,0 +1,15 @@
+Discover skills and commands from other AI tools (Claude Code, Codex CLI, Gemini CLI) and load them into the current session.
+
+## Instructions
+
+1. First, call the `skill_discover` tool with `action: "list"` to see what's available.
+
+2. Show the user the results — which skills are new and which are already loaded.
+
+3. If there are new skills, ask the user which ones they want to add.
+
+4. Call `skill_discover` with `action: "add"` and the selected `skills` array (or omit to add all).
+
+5. Report what was added and how to use them (e.g., `/skill-name`).
+
+If $ARGUMENTS contains specific skill names, filter to just those.

packages/opencode/src/config/config.ts

@@ -1300,6 +1300,12 @@ export namespace Config {
             .default(true)
             .describe("Auto-discover MCP servers from VS Code, Claude Code, Copilot, and Gemini configs at startup. Set to false to disable."),
           // altimate_change end
+          // altimate_change start - auto skill/command discovery toggle
+          auto_skill_discovery: z
+            .boolean()
+            .default(false)
+            .describe("Auto-discover skills and commands from Claude Code, Codex, and Gemini configs at startup. Opt-in — set to true to enable."),
+          // altimate_change end
         })
         .optional(),
     })