@every-env/compound-plugin 0.9.0 → 2.34.2

package/src/converters/claude-to-windsurf.ts

@@ -0,0 +1,205 @@
+import { formatFrontmatter } from "../utils/frontmatter"
+import { findServersWithPotentialSecrets } from "../utils/secrets"
+import type { ClaudeAgent, ClaudeCommand, ClaudeMcpServer, ClaudePlugin } from "../types/claude"
+import type { WindsurfBundle, WindsurfGeneratedSkill, WindsurfMcpConfig, WindsurfMcpServerEntry, WindsurfWorkflow } from "../types/windsurf"
+import type { ClaudeToOpenCodeOptions } from "./claude-to-opencode"
+
+export type ClaudeToWindsurfOptions = ClaudeToOpenCodeOptions
+
+const WINDSURF_WORKFLOW_CHAR_LIMIT = 12_000
+
+export function convertClaudeToWindsurf(
+  plugin: ClaudePlugin,
+  _options: ClaudeToWindsurfOptions,
+): WindsurfBundle {
+  const knownAgentNames = plugin.agents.map((a) => normalizeName(a.name))
+
+  // Pass-through skills (collected first so agent skill names can deduplicate against them)
+  const skillDirs = plugin.skills.map((skill) => ({
+    name: skill.name,
+    sourceDir: skill.sourceDir,
+  }))
+
+  // Convert agents to skills (seed usedNames with pass-through skill names)
+  const usedSkillNames = new Set<string>(skillDirs.map((s) => s.name))
+  const agentSkills = plugin.agents.map((agent) =>
+    convertAgentToSkill(agent, knownAgentNames, usedSkillNames),
+  )
+
+  // Convert commands to workflows
+  const usedCommandNames = new Set<string>()
+  const commandWorkflows = plugin.commands.map((command) =>
+    convertCommandToWorkflow(command, knownAgentNames, usedCommandNames),
+  )
+
+  // Build MCP config
+  const mcpConfig = buildMcpConfig(plugin.mcpServers)
+
+  // Warn about hooks
+  if (plugin.hooks && Object.keys(plugin.hooks.hooks).length > 0) {
+    console.warn(
+      "Warning: Windsurf has no hooks equivalent. Hooks were skipped during conversion.",
+    )
+  }
+
+  return { agentSkills, commandWorkflows, skillDirs, mcpConfig }
+}
+
+function convertAgentToSkill(
+  agent: ClaudeAgent,
+  knownAgentNames: string[],
+  usedNames: Set<string>,
+): WindsurfGeneratedSkill {
+  const name = uniqueName(normalizeName(agent.name), usedNames)
+  const description = sanitizeDescription(
+    agent.description ?? `Converted from Claude agent ${agent.name}`,
+  )
+
+  let body = transformContentForWindsurf(agent.body.trim(), knownAgentNames)
+  if (agent.capabilities && agent.capabilities.length > 0) {
+    const capabilities = agent.capabilities.map((c) => `- ${c}`).join("\n")
+    body = `## Capabilities\n${capabilities}\n\n${body}`.trim()
+  }
+  if (body.length === 0) {
+    body = `Instructions converted from the ${agent.name} agent.`
+  }
+
+  const content = formatFrontmatter({ name, description }, `# ${name}\n\n${body}`) + "\n"
+  return { name, content }
+}
+
+function convertCommandToWorkflow(
+  command: ClaudeCommand,
+  knownAgentNames: string[],
+  usedNames: Set<string>,
+): WindsurfWorkflow {
+  const name = uniqueName(normalizeName(command.name), usedNames)
+  const description = sanitizeDescription(
+    command.description ?? `Converted from Claude command ${command.name}`,
+  )
+
+  let body = transformContentForWindsurf(command.body.trim(), knownAgentNames)
+  if (command.argumentHint) {
+    body = `> Arguments: ${command.argumentHint}\n\n${body}`
+  }
+  if (body.length === 0) {
+    body = `Instructions converted from the ${command.name} command.`
+  }
+
+  const frontmatter: Record<string, unknown> = { description }
+  const fullContent = formatFrontmatter(frontmatter, `# ${name}\n\n${body}`)
+  if (fullContent.length > WINDSURF_WORKFLOW_CHAR_LIMIT) {
+    console.warn(
+      `Warning: Workflow "${name}" is ${fullContent.length} characters (limit: ${WINDSURF_WORKFLOW_CHAR_LIMIT}). It may be truncated by Windsurf.`,
+    )
+  }
+
+  return { name, description, body }
+}
+
+/**
+ * Transform Claude Code content to Windsurf-compatible content.
+ *
+ * 1. Path rewriting: .claude/ -> .windsurf/, ~/.claude/ -> ~/.codeium/windsurf/
+ * 2. Slash command refs: /workflows:plan -> /workflows-plan (Windsurf invokes workflows as /{name})
+ * 3. @agent-name refs: kept as @agent-name (already Windsurf skill invocation syntax)
+ * 4. Task agent calls: Task agent-name(args) -> Use the @agent-name skill: args
+ */
+export function transformContentForWindsurf(body: string, knownAgentNames: string[] = []): string {
+  let result = body
+
+  // 1. Rewrite paths
+  result = result.replace(/(?<=^|\s|["'`])~\/\.claude\//gm, "~/.codeium/windsurf/")
+  result = result.replace(/(?<=^|\s|["'`])\.claude\//gm, ".windsurf/")
+
+  // 2. Slash command refs: /workflows:plan -> /workflows-plan (Windsurf invokes as /{name})
+  result = result.replace(/(?<=^|\s)`?\/([a-zA-Z][a-zA-Z0-9_:-]*)`?/gm, (_match, cmdName: string) => {
+    const workflowName = normalizeName(cmdName)
+    return `/${workflowName}`
+  })
+
+  // 3. @agent-name references: no transformation needed.
+  // In Windsurf, @skill-name is the native invocation syntax for skills.
+  // Since agents are now mapped to skills, @agent-name already works correctly.
+
+  // 4. Transform Task agent calls to skill references
+  const taskPattern = /^(\s*-?\s*)Task\s+([a-z][a-z0-9-]*)\(([^)]+)\)/gm
+  result = result.replace(taskPattern, (_match, prefix: string, agentName: string, args: string) => {
+    return `${prefix}Use the @${normalizeName(agentName)} skill: ${args.trim()}`
+  })
+
+  return result
+}
+
+function buildMcpConfig(servers?: Record<string, ClaudeMcpServer>): WindsurfMcpConfig | null {
+  if (!servers || Object.keys(servers).length === 0) return null
+
+  const result: Record<string, WindsurfMcpServerEntry> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      // stdio transport
+      const entry: WindsurfMcpServerEntry = { command: server.command }
+      if (server.args?.length) entry.args = server.args
+      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
+      result[name] = entry
+    } else if (server.url) {
+      // HTTP/SSE transport
+      const entry: WindsurfMcpServerEntry = { serverUrl: server.url }
+      if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
+      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
+      result[name] = entry
+    } else {
+      console.warn(`Warning: MCP server "${name}" has no command or URL. Skipping.`)
+      continue
+    }
+  }
+
+  if (Object.keys(result).length === 0) return null
+
+  // Warn about secrets (don't redact — they're needed for the config to work)
+  const flagged = findServersWithPotentialSecrets(result)
+  if (flagged.length > 0) {
+    console.warn(
+      `Warning: MCP servers contain env vars that may include secrets: ${flagged.join(", ")}.\n` +
+      "   These will be written to mcp_config.json. Review before sharing the config file.",
+    )
+  }
+
+  return { mcpServers: result }
+}
+
+export function normalizeName(value: string): string {
+  const trimmed = value.trim()
+  if (!trimmed) return "item"
+  let normalized = trimmed
+    .toLowerCase()
+    .replace(/[\\/]+/g, "-")
+    .replace(/[:\s]+/g, "-")
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "")
+
+  if (normalized.length === 0 || !/^[a-z]/.test(normalized)) {
+    return "item"
+  }
+
+  return normalized
+}
+
+function sanitizeDescription(value: string): string {
+  return value.replace(/\s+/g, " ").trim()
+}
+
+function uniqueName(base: string, used: Set<string>): string {
+  if (!used.has(base)) {
+    used.add(base)
+    return base
+  }
+  let index = 2
+  while (used.has(`${base}-${index}`)) {
+    index += 1
+  }
+  const name = `${base}-${index}`
+  used.add(name)
+  return name
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { defineCommand, runMain } from "citty"
+import packageJson from "../package.json"
 import convert from "./commands/convert"
 import install from "./commands/install"
 import listCommand from "./commands/list"
@@ -8,7 +9,7 @@ import sync from "./commands/sync"
 const main = defineCommand({
   meta: {
     name: "compound-plugin",
-    version: "0.1.0",
+    version: packageJson.version,
     description: "Convert Claude Code plugins into other agent formats",
   },
   subCommands: {

package/src/parsers/claude-home.ts

@@ -1,22 +1,26 @@
 import path from "path"
 import os from "os"
 import fs from "fs/promises"
-import type { ClaudeSkill, ClaudeMcpServer } from "../types/claude"
+import { parseFrontmatter } from "../utils/frontmatter"
+import { walkFiles } from "../utils/files"
+import type { ClaudeCommand, ClaudeSkill, ClaudeMcpServer } from "../types/claude"
 
 export interface ClaudeHomeConfig {
   skills: ClaudeSkill[]
+  commands?: ClaudeCommand[]
   mcpServers: Record<string, ClaudeMcpServer>
 }
 
 export async function loadClaudeHome(claudeHome?: string): Promise<ClaudeHomeConfig> {
   const home = claudeHome ?? path.join(os.homedir(), ".claude")
 
-  const [skills, mcpServers] = await Promise.all([
+  const [skills, commands, mcpServers] = await Promise.all([
     loadPersonalSkills(path.join(home, "skills")),
+    loadPersonalCommands(path.join(home, "commands")),
     loadSettingsMcp(path.join(home, "settings.json")),
   ])
 
-  return { skills, mcpServers }
+  return { skills, commands, mcpServers }
 }
 
 async function loadPersonalSkills(skillsDir: string): Promise<ClaudeSkill[]> {
@@ -63,3 +67,51 @@ async function loadSettingsMcp(
     return {} // File doesn't exist or invalid JSON
   }
 }
+
+async function loadPersonalCommands(commandsDir: string): Promise<ClaudeCommand[]> {
+  try {
+    const files = (await walkFiles(commandsDir))
+      .filter((file) => file.endsWith(".md"))
+      .sort()
+
+    const commands: ClaudeCommand[] = []
+    for (const file of files) {
+      const raw = await fs.readFile(file, "utf8")
+      const { data, body } = parseFrontmatter(raw)
+      commands.push({
+        name: typeof data.name === "string" ? data.name : deriveCommandName(commandsDir, file),
+        description: data.description as string | undefined,
+        argumentHint: data["argument-hint"] as string | undefined,
+        model: data.model as string | undefined,
+        allowedTools: parseAllowedTools(data["allowed-tools"]),
+        disableModelInvocation: data["disable-model-invocation"] === true ? true : undefined,
+        body: body.trim(),
+        sourcePath: file,
+      })
+    }
+
+    return commands
+  } catch {
+    return []
+  }
+}
+
+function deriveCommandName(commandsDir: string, filePath: string): string {
+  const relative = path.relative(commandsDir, filePath)
+  const withoutExt = relative.replace(/\.md$/i, "")
+  return withoutExt.split(path.sep).join(":")
+}
+
+function parseAllowedTools(value: unknown): string[] | undefined {
+  if (!value) return undefined
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item))
+  }
+  if (typeof value === "string") {
+    return value
+      .split(/,/)
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+  return undefined
+}

package/src/sync/codex.ts

@@ -1,31 +1,29 @@
 import fs from "fs/promises"
 import path from "path"
 import type { ClaudeHomeConfig } from "../parsers/claude-home"
-import type { ClaudeMcpServer } from "../types/claude"
-import { forceSymlink, isValidSkillName } from "../utils/symlink"
+import { renderCodexConfig } from "../targets/codex"
+import { writeTextSecure } from "../utils/files"
+import { syncCodexCommands } from "./commands"
+import { syncSkills } from "./skills"
+
+const CURRENT_START_MARKER = "# BEGIN compound-plugin Claude Code MCP"
+const CURRENT_END_MARKER = "# END compound-plugin Claude Code MCP"
+const LEGACY_MARKER = "# MCP servers synced from Claude Code"
 
 export async function syncToCodex(
   config: ClaudeHomeConfig,
   outputRoot: string,
 ): Promise<void> {
-  // Ensure output directories exist
-  const skillsDir = path.join(outputRoot, "skills")
-  await fs.mkdir(skillsDir, { recursive: true })
-
-  // Symlink skills (with validation)
-  for (const skill of config.skills) {
-    if (!isValidSkillName(skill.name)) {
-      console.warn(`Skipping skill with invalid name: ${skill.name}`)
-      continue
-    }
-    const target = path.join(skillsDir, skill.name)
-    await forceSymlink(skill.sourceDir, target)
-  }
+  await syncSkills(config.skills, path.join(outputRoot, "skills"))
+  await syncCodexCommands(config, outputRoot)
 
   // Write MCP servers to config.toml (TOML format)
   if (Object.keys(config.mcpServers).length > 0) {
     const configPath = path.join(outputRoot, "config.toml")
-    const mcpToml = convertMcpForCodex(config.mcpServers)
+    const mcpToml = renderCodexConfig(config.mcpServers)
+    if (!mcpToml) {
+      return
+    }
 
     // Read existing config and merge idempotently
     let existingContent = ""
@@ -37,56 +35,34 @@ export async function syncToCodex(
       }
     }
 
-    // Remove any existing Claude Code MCP section to make idempotent
-    const marker = "# MCP servers synced from Claude Code"
-    const markerIndex = existingContent.indexOf(marker)
-    if (markerIndex !== -1) {
-      existingContent = existingContent.slice(0, markerIndex).trimEnd()
-    }
-
-    const newContent = existingContent
-      ? existingContent + "\n\n" + marker + "\n" + mcpToml
-      : "# Codex config - synced from Claude Code\n\n" + mcpToml
-
-    await fs.writeFile(configPath, newContent, { mode: 0o600 })
-  }
-}
-
-/** Escape a string for TOML double-quoted strings */
-function escapeTomlString(str: string): string {
-  return str
-    .replace(/\\/g, "\\\\")
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, "\\n")
-    .replace(/\r/g, "\\r")
-    .replace(/\t/g, "\\t")
-}
+    const managedBlock = [
+      CURRENT_START_MARKER,
+      mcpToml.trim(),
+      CURRENT_END_MARKER,
+      "",
+    ].join("\n")
 
-function convertMcpForCodex(servers: Record<string, ClaudeMcpServer>): string {
-  const sections: string[] = []
+    const withoutCurrentBlock = existingContent.replace(
+      new RegExp(
+        `${escapeForRegex(CURRENT_START_MARKER)}[\\s\\S]*?${escapeForRegex(CURRENT_END_MARKER)}\\n?`,
+        "g",
+      ),
+      "",
+    ).trimEnd()
 
-  for (const [name, server] of Object.entries(servers)) {
-    if (!server.command) continue
+    const legacyMarkerIndex = withoutCurrentBlock.indexOf(LEGACY_MARKER)
+    const cleaned = legacyMarkerIndex === -1
+      ? withoutCurrentBlock
+      : withoutCurrentBlock.slice(0, legacyMarkerIndex).trimEnd()
 
-    const lines: string[] = []
-    lines.push(`[mcp_servers.${name}]`)
-    lines.push(`command = "${escapeTomlString(server.command)}"`)
-
-    if (server.args && server.args.length > 0) {
-      const argsStr = server.args.map((arg) => `"${escapeTomlString(arg)}"`).join(", ")
-      lines.push(`args = [${argsStr}]`)
-    }
+    const newContent = cleaned
+      ? `${cleaned}\n\n${managedBlock}`
+      : `${managedBlock}`
 
-    if (server.env && Object.keys(server.env).length > 0) {
-      lines.push("")
-      lines.push(`[mcp_servers.${name}.env]`)
-      for (const [key, value] of Object.entries(server.env)) {
-        lines.push(`${key} = "${escapeTomlString(value)}"`)
-      }
-    }
-
-    sections.push(lines.join("\n"))
+    await writeTextSecure(configPath, newContent)
   }
+}
 
-  return sections.join("\n\n") + "\n"
+function escapeForRegex(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
 }

package/src/sync/commands.ts

@@ -0,0 +1,198 @@
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import type { ClaudePlugin } from "../types/claude"
+import { backupFile, writeText } from "../utils/files"
+import { convertClaudeToCodex } from "../converters/claude-to-codex"
+import { convertClaudeToCopilot } from "../converters/claude-to-copilot"
+import { convertClaudeToDroid } from "../converters/claude-to-droid"
+import { convertClaudeToGemini } from "../converters/claude-to-gemini"
+import { convertClaudeToKiro } from "../converters/claude-to-kiro"
+import { convertClaudeToOpenCode, type ClaudeToOpenCodeOptions } from "../converters/claude-to-opencode"
+import { convertClaudeToPi } from "../converters/claude-to-pi"
+import { convertClaudeToQwen, type ClaudeToQwenOptions } from "../converters/claude-to-qwen"
+import { convertClaudeToWindsurf } from "../converters/claude-to-windsurf"
+import { writeWindsurfBundle } from "../targets/windsurf"
+
+type WindsurfSyncScope = "global" | "workspace"
+
+const HOME_SYNC_PLUGIN_ROOT = path.join(process.cwd(), ".compound-sync-home")
+
+const DEFAULT_SYNC_OPTIONS: ClaudeToOpenCodeOptions = {
+  agentMode: "subagent",
+  inferTemperature: false,
+  permissions: "none",
+}
+
+const DEFAULT_QWEN_SYNC_OPTIONS: ClaudeToQwenOptions = {
+  agentMode: "subagent",
+  inferTemperature: false,
+}
+
+function hasCommands(config: ClaudeHomeConfig): boolean {
+  return (config.commands?.length ?? 0) > 0
+}
+
+function buildClaudeHomePlugin(config: ClaudeHomeConfig): ClaudePlugin {
+  return {
+    root: HOME_SYNC_PLUGIN_ROOT,
+    manifest: {
+      name: "claude-home",
+      version: "1.0.0",
+      description: "Personal Claude Code home config",
+    },
+    agents: [],
+    commands: config.commands ?? [],
+    skills: config.skills,
+    mcpServers: undefined,
+  }
+}
+
+export async function syncOpenCodeCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToOpenCode(plugin, DEFAULT_SYNC_OPTIONS)
+
+  for (const commandFile of bundle.commandFiles) {
+    const commandPath = path.join(outputRoot, "commands", `${commandFile.name}.md`)
+    const backupPath = await backupFile(commandPath)
+    if (backupPath) {
+      console.log(`Backed up existing command file to ${backupPath}`)
+    }
+    await writeText(commandPath, commandFile.content + "\n")
+  }
+}
+
+export async function syncCodexCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToCodex(plugin, DEFAULT_SYNC_OPTIONS)
+  for (const prompt of bundle.prompts) {
+    await writeText(path.join(outputRoot, "prompts", `${prompt.name}.md`), prompt.content + "\n")
+  }
+  for (const skill of bundle.generatedSkills) {
+    await writeText(path.join(outputRoot, "skills", skill.name, "SKILL.md"), skill.content + "\n")
+  }
+}
+
+export async function syncPiCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToPi(plugin, DEFAULT_SYNC_OPTIONS)
+  for (const prompt of bundle.prompts) {
+    await writeText(path.join(outputRoot, "prompts", `${prompt.name}.md`), prompt.content + "\n")
+  }
+  for (const extension of bundle.extensions) {
+    await writeText(path.join(outputRoot, "extensions", extension.name), extension.content + "\n")
+  }
+}
+
+export async function syncDroidCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToDroid(plugin, DEFAULT_SYNC_OPTIONS)
+  for (const command of bundle.commands) {
+    await writeText(path.join(outputRoot, "commands", `${command.name}.md`), command.content + "\n")
+  }
+}
+
+export async function syncCopilotCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToCopilot(plugin, DEFAULT_SYNC_OPTIONS)
+
+  for (const skill of bundle.generatedSkills) {
+    await writeText(path.join(outputRoot, "skills", skill.name, "SKILL.md"), skill.content + "\n")
+  }
+}
+
+export async function syncGeminiCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToGemini(plugin, DEFAULT_SYNC_OPTIONS)
+  for (const command of bundle.commands) {
+    await writeText(path.join(outputRoot, "commands", `${command.name}.toml`), command.content + "\n")
+  }
+}
+
+export async function syncKiroCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToKiro(plugin, DEFAULT_SYNC_OPTIONS)
+  for (const skill of bundle.generatedSkills) {
+    await writeText(path.join(outputRoot, "skills", skill.name, "SKILL.md"), skill.content + "\n")
+  }
+}
+
+export async function syncWindsurfCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+  scope: WindsurfSyncScope = "global",
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToWindsurf(plugin, DEFAULT_SYNC_OPTIONS)
+  await writeWindsurfBundle(outputRoot, {
+    agentSkills: [],
+    commandWorkflows: bundle.commandWorkflows,
+    skillDirs: [],
+    mcpConfig: null,
+  }, scope)
+}
+
+export async function syncQwenCommands(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  if (!hasCommands(config)) return
+
+  const plugin = buildClaudeHomePlugin(config)
+  const bundle = convertClaudeToQwen(plugin, DEFAULT_QWEN_SYNC_OPTIONS)
+
+  for (const commandFile of bundle.commandFiles) {
+    const parts = commandFile.name.split(":")
+    if (parts.length > 1) {
+      const nestedDir = path.join(outputRoot, "commands", ...parts.slice(0, -1))
+      await writeText(path.join(nestedDir, `${parts[parts.length - 1]}.md`), commandFile.content + "\n")
+      continue
+    }
+
+    await writeText(path.join(outputRoot, "commands", `${commandFile.name}.md`), commandFile.content + "\n")
+  }
+}
+
+export function warnUnsupportedOpenClawCommands(config: ClaudeHomeConfig): void {
+  if (!hasCommands(config)) return
+
+  console.warn(
+    "Warning: OpenClaw personal command sync is skipped because this sync target currently has no documented user-level command surface.",
+  )
+}