@every-env/compound-plugin 0.12.0 → 2.34.3

package/plugins/compound-engineering/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "compound-engineering",
-  "version": "2.38.0",
+  "version": "2.38.1",
   "description": "AI-powered development tools. 29 agents, 22 commands, 20 skills, 1 MCP server for code review, research, design, and workflow automation.",
   "author": {
     "name": "Kieran Klaassen",

package/plugins/compound-engineering/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to the compound-engineering plugin will be documented in thi
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.38.1] - 2026-03-01
+
+### Fixed
+
+- **Cross-platform `AskUserQuestion` fallback** — `setup` skill and `create-new-skill`/`add-workflow` workflows now include an "Interaction Method" preamble that instructs non-Claude LLMs (Codex, Gemini, Copilot, Kiro) to use numbered lists instead of `AskUserQuestion`, preventing silent auto-configuration. ([#204](https://github.com/EveryInc/compound-engineering-plugin/issues/204))
+- **Codex AGENTS.md `AskUserQuestion` mapping** — Strengthened from "ask the user in chat" to structured numbered-list guidance with multi-select support and a "never skip or auto-configure" rule.
+- **Skill compliance checklist** — Added `AskUserQuestion` lint rule to `CLAUDE.md` to prevent recurrence.
+
+---
+
 ## [2.38.0] - 2026-03-01
 
 ### Changed

package/plugins/compound-engineering/CLAUDE.md

@@ -75,6 +75,11 @@ When adding or modifying skills, verify compliance with skill-creator spec:
 - [ ] Use imperative/infinitive form (verb-first instructions)
 - [ ] Avoid second person ("you should") - use objective language ("To accomplish X, do Y")
 
+### AskUserQuestion Usage
+
+- [ ] If the skill uses `AskUserQuestion`, it must include an "Interaction Method" preamble explaining the numbered-list fallback for non-Claude environments
+- [ ] Prefer avoiding `AskUserQuestion` entirely (see `brainstorming/SKILL.md` pattern) for skills intended to run cross-platform
+
 ### Quick Validation Command
 
 ```bash

package/plugins/compound-engineering/skills/create-agent-skills/workflows/add-workflow.md

@@ -1,5 +1,11 @@
 # Workflow: Add a Workflow to Existing Skill
 
+## Interaction Method
+
+If `AskUserQuestion` is available, use it for all prompts below.
+
+If not, present each question as a numbered list and wait for a reply before proceeding to the next step. Never skip or auto-configure.
+
 <required_reading>
 **Read these reference files NOW:**
 1. references/recommended-structure.md

package/plugins/compound-engineering/skills/create-agent-skills/workflows/create-new-skill.md

@@ -1,5 +1,11 @@
 # Workflow: Create a New Skill
 
+## Interaction Method
+
+If `AskUserQuestion` is available, use it for all prompts below.
+
+If not, present each question as a numbered list and wait for a reply before proceeding to the next step. For multiSelect questions, accept comma-separated numbers (e.g. `1, 3`). Never skip or auto-configure.
+
 <required_reading>
 **Read these reference files NOW:**
 1. references/recommended-structure.md

package/plugins/compound-engineering/skills/setup/SKILL.md

@@ -6,6 +6,12 @@ disable-model-invocation: true
 
 # Compound Engineering Setup
 
+## Interaction Method
+
+If `AskUserQuestion` is available, use it for all prompts below.
+
+If not, present each question as a numbered list and wait for a reply before proceeding to the next step. For multiSelect questions, accept comma-separated numbers (e.g. `1, 3`). Never skip or auto-configure.
+
 Interactive setup for `compound-engineering.local.md` — configures which agents run during `/ce:review` and `/ce:work`.
 
 ## Step 1: Check Existing Config

package/src/commands/sync.ts

@@ -1,76 +1,34 @@
 import { defineCommand } from "citty"
-import os from "os"
 import path from "path"
 import { loadClaudeHome } from "../parsers/claude-home"
-import { syncToOpenCode } from "../sync/opencode"
-import { syncToCodex } from "../sync/codex"
-import { syncToPi } from "../sync/pi"
-import { syncToDroid } from "../sync/droid"
-import { syncToCopilot } from "../sync/copilot"
-import { syncToGemini } from "../sync/gemini"
+import {
+  getDefaultSyncRegistryContext,
+  getSyncTarget,
+  isSyncTargetName,
+  syncTargetNames,
+  type SyncTargetName,
+} from "../sync/registry"
 import { expandHome } from "../utils/resolve-home"
 import { hasPotentialSecrets } from "../utils/secrets"
 import { detectInstalledTools } from "../utils/detect-tools"
 
-const validTargets = ["opencode", "codex", "pi", "droid", "copilot", "gemini", "all"] as const
-type SyncTarget = (typeof validTargets)[number]
+const validTargets = [...syncTargetNames, "all"] as const
+type SyncTarget = SyncTargetName | "all"
 
 function isValidTarget(value: string): value is SyncTarget {
-  return (validTargets as readonly string[]).includes(value)
-}
-
-function resolveOutputRoot(target: string): string {
-  switch (target) {
-    case "opencode":
-      return path.join(os.homedir(), ".config", "opencode")
-    case "codex":
-      return path.join(os.homedir(), ".codex")
-    case "pi":
-      return path.join(os.homedir(), ".pi", "agent")
-    case "droid":
-      return path.join(os.homedir(), ".factory")
-    case "copilot":
-      return path.join(process.cwd(), ".github")
-    case "gemini":
-      return path.join(process.cwd(), ".gemini")
-    default:
-      throw new Error(`No output root for target: ${target}`)
-  }
-}
-
-async function syncTarget(target: string, config: Awaited<ReturnType<typeof loadClaudeHome>>, outputRoot: string): Promise<void> {
-  switch (target) {
-    case "opencode":
-      await syncToOpenCode(config, outputRoot)
-      break
-    case "codex":
-      await syncToCodex(config, outputRoot)
-      break
-    case "pi":
-      await syncToPi(config, outputRoot)
-      break
-    case "droid":
-      await syncToDroid(config, outputRoot)
-      break
-    case "copilot":
-      await syncToCopilot(config, outputRoot)
-      break
-    case "gemini":
-      await syncToGemini(config, outputRoot)
-      break
-  }
+  return value === "all" || isSyncTargetName(value)
 }
 
 export default defineCommand({
   meta: {
     name: "sync",
-    description: "Sync Claude Code config (~/.claude/) to OpenCode, Codex, Pi, Droid, Copilot, or Gemini",
+    description: "Sync Claude Code config (~/.claude/) to supported provider configs and skills",
   },
   args: {
     target: {
       type: "string",
       default: "all",
-      description: "Target: opencode | codex | pi | droid | copilot | gemini | all (default: all)",
+      description: `Target: ${syncTargetNames.join(" | ")} | all (default: all)`,
     },
     claudeHome: {
       type: "string",
@@ -83,7 +41,8 @@ export default defineCommand({
       throw new Error(`Unknown target: ${args.target}. Use one of: ${validTargets.join(", ")}`)
     }
 
-    const claudeHome = expandHome(args.claudeHome ?? path.join(os.homedir(), ".claude"))
+    const { home, cwd } = getDefaultSyncRegistryContext()
+    const claudeHome = expandHome(args.claudeHome ?? path.join(home, ".claude"))
     const config = await loadClaudeHome(claudeHome)
 
     // Warn about potential secrets in MCP env vars
@@ -109,19 +68,21 @@ export default defineCommand({
       }
 
       for (const name of activeTargets) {
-        const outputRoot = resolveOutputRoot(name)
-        await syncTarget(name, config, outputRoot)
+        const target = getSyncTarget(name as SyncTargetName)
+        const outputRoot = target.resolveOutputRoot(home, cwd)
+        await target.sync(config, outputRoot)
         console.log(`✓ Synced to ${name}: ${outputRoot}`)
       }
       return
     }
 
     console.log(
-      `Syncing ${config.skills.length} skills, ${Object.keys(config.mcpServers).length} MCP servers...`,
+      `Syncing ${config.skills.length} skills, ${config.commands?.length ?? 0} commands, ${Object.keys(config.mcpServers).length} MCP servers...`,
     )
 
-    const outputRoot = resolveOutputRoot(args.target)
-    await syncTarget(args.target, config, outputRoot)
+    const target = getSyncTarget(args.target as SyncTargetName)
+    const outputRoot = target.resolveOutputRoot(home, cwd)
+    await target.sync(config, outputRoot)
     console.log(`✓ Synced to ${args.target}: ${outputRoot}`)
   },
 })

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.",
+  )
+}