@powerformer/refly-cli 0.1.23 → 0.1.25

package/dist/bin/refly.js

@@ -989,8 +989,8 @@ var require_command = __commonJS({
     init_cjs_shims();
     var EventEmitter = require("events").EventEmitter;
     var childProcess2 = require("child_process");
-    var path22 = require("path");
-    var fs27 = require("fs");
+    var path25 = require("path");
+    var fs32 = require("fs");
     var process8 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1922,11 +1922,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path22.resolve(baseDir, baseName);
-          if (fs27.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path22.extname(baseName))) return void 0;
+          const localBin = path25.resolve(baseDir, baseName);
+          if (fs32.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path25.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs27.existsSync(`${localBin}${ext}`)
+            (ext) => fs32.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1938,21 +1938,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs27.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs32.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path22.resolve(
-            path22.dirname(resolvedScriptPath),
+          executableDir = path25.resolve(
+            path25.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path22.basename(
+            const legacyName = path25.basename(
               this._scriptPath,
-              path22.extname(this._scriptPath)
+              path25.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1963,7 +1963,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path22.extname(executableFile));
+        launchWithNode = sourceExt.includes(path25.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2803,7 +2803,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path22.basename(filename, path22.extname(filename));
+        this._name = path25.basename(filename, path25.extname(filename));
         return this;
       }
       /**
@@ -2817,9 +2817,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path23) {
-        if (path23 === void 0) return this._executableDir;
-        this._executableDir = path23;
+      executableDir(path26) {
+        if (path26 === void 0) return this._executableDir;
+        this._executableDir = path26;
         return this;
       }
       /**
@@ -3260,17 +3260,865 @@ var init_logger = __esm({
   }
 });
 
+// src/platform/registry.ts
+function pathExists(p) {
+  try {
+    return fs4.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+function isValidAgentType(name) {
+  return name in agents;
+}
+var fs4, path4, import_node_os, home, agents;
+var init_registry = __esm({
+  "src/platform/registry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs4 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
+    import_node_os = require("os");
+    home = (0, import_node_os.homedir)();
+    agents = {
+      // === SKILL.md Format (Symlink Compatible) ===
+      "claude-code": {
+        name: "claude-code",
+        displayName: "Claude Code",
+        format: "skill-md",
+        skillsDir: ".claude/skills",
+        globalSkillsDir: path4.join(home, ".claude", "skills"),
+        detectInstalled: async () => pathExists(path4.join(home, ".claude"))
+      },
+      codex: {
+        name: "codex",
+        displayName: "Codex",
+        format: "skill-md",
+        skillsDir: ".codex/skills",
+        globalSkillsDir: process.env.CODEX_HOME ? path4.join(process.env.CODEX_HOME, "skills") : path4.join(home, ".codex", "skills"),
+        detectInstalled: async () => pathExists(path4.join(home, ".codex"))
+      },
+      antigravity: {
+        name: "antigravity",
+        displayName: "Antigravity",
+        format: "skill-md",
+        skillsDir: ".agent/skills",
+        globalSkillsDir: path4.join(home, ".gemini", "antigravity", "skills"),
+        detectInstalled: async () => pathExists(path4.join(home, ".gemini", "antigravity"))
+      },
+      "github-copilot": {
+        name: "github-copilot",
+        displayName: "GitHub Copilot",
+        format: "skill-md",
+        skillsDir: ".github/skills",
+        globalSkillsDir: path4.join(home, ".copilot", "skills"),
+        detectInstalled: async () => pathExists(path4.join(home, ".copilot"))
+      },
+      windsurf: {
+        name: "windsurf",
+        displayName: "Windsurf",
+        format: "skill-md",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: path4.join(home, ".codeium", "windsurf", "skills"),
+        detectInstalled: async () => pathExists(path4.join(home, ".codeium", "windsurf"))
+      },
+      opencode: {
+        name: "opencode",
+        displayName: "OpenCode",
+        format: "skill-md",
+        skillsDir: ".opencode/skill",
+        globalSkillsDir: path4.join(home, ".config", "opencode", "skill"),
+        detectInstalled: async () => pathExists(path4.join(home, ".config", "opencode"))
+      },
+      moltbot: {
+        name: "moltbot",
+        displayName: "Moltbot",
+        format: "skill-md",
+        skillsDir: "skills",
+        // <workspace>/skills
+        globalSkillsDir: path4.join(home, ".clawdbot", "skills"),
+        // Note: .clawdbot not .moltbot
+        detectInstalled: async () => pathExists(path4.join(home, ".clawdbot"))
+      },
+      // === Different Formats (Require Conversion) ===
+      cursor: {
+        name: "cursor",
+        displayName: "Cursor",
+        format: "cursor-mdc",
+        skillsDir: ".cursor/rules",
+        globalSkillsDir: null,
+        // Cursor has no global rules directory
+        detectInstalled: async () => pathExists(path4.join(home, ".cursor")),
+        fileExtension: ".mdc",
+        skillsAsFiles: true
+      },
+      continue: {
+        name: "continue",
+        displayName: "Continue",
+        format: "rules-md",
+        skillsDir: ".continue/rules",
+        globalSkillsDir: path4.join(home, ".continue", "rules"),
+        detectInstalled: async () => pathExists(path4.join(home, ".continue")),
+        fileExtension: ".md",
+        skillsAsFiles: true
+      },
+      trae: {
+        name: "trae",
+        displayName: "Trae",
+        format: "rules-md",
+        skillsDir: ".trae/rules",
+        globalSkillsDir: path4.join(home, ".trae", "rules"),
+        detectInstalled: async () => pathExists(path4.join(home, ".trae")),
+        fileExtension: ".md",
+        skillsAsFiles: true
+      },
+      // === Unverified ===
+      qoder: {
+        name: "qoder",
+        displayName: "Qoder",
+        format: "unknown",
+        skillsDir: ".qoder/skills",
+        // Assumed, not verified
+        globalSkillsDir: path4.join(home, ".qoder", "skills"),
+        detectInstalled: async () => pathExists(path4.join(home, ".qoder"))
+      }
+    };
+  }
+});
+
+// src/platform/symlink-adapter.ts
+async function createSymlinkSafe(target, linkPath) {
+  try {
+    const linkDir = path5.dirname(linkPath);
+    ensureDir(linkDir);
+    if (fs5.existsSync(linkPath)) {
+      const stat = fs5.lstatSync(linkPath);
+      if (stat.isSymbolicLink()) {
+        fs5.unlinkSync(linkPath);
+        logger.debug(`Removed existing symlink: ${linkPath}`);
+      } else if (stat.isDirectory()) {
+        return {
+          success: false,
+          error: `Target path is a directory, not a symlink: ${linkPath}`
+        };
+      }
+    }
+    const symlinkType = (0, import_node_os2.platform)() === "win32" ? "junction" : "dir";
+    fs5.symlinkSync(target, linkPath, symlinkType);
+    logger.debug(`Created symlink: ${linkPath} -> ${target}`);
+    return { success: true };
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      try {
+        const symlinkType = (0, import_node_os2.platform)() === "win32" ? "junction" : "dir";
+        fs5.symlinkSync(target, linkPath, symlinkType);
+        logger.debug(`Created symlink: ${linkPath} -> ${target}`);
+        return { success: true };
+      } catch (innerErr) {
+        return {
+          success: false,
+          error: innerErr.message
+        };
+      }
+    }
+    return {
+      success: false,
+      error: err.message
+    };
+  }
+}
+var fs5, path5, import_node_os2, SymlinkAdapter, symlinkAdapter;
+var init_symlink_adapter = __esm({
+  "src/platform/symlink-adapter.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs5 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
+    import_node_os2 = require("os");
+    init_logger();
+    init_paths();
+    SymlinkAdapter = class {
+      async deploy(skillName, sourcePath, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          deployedPath: null,
+          sourcePath,
+          isSymlink: true
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path5.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.error = `Agent ${agent.displayName} has no skills directory configured`;
+          return result;
+        }
+        if (!fs5.existsSync(sourcePath)) {
+          result.error = `Source skill directory does not exist: ${sourcePath}`;
+          return result;
+        }
+        const linkPath = path5.join(targetDir, skillName);
+        result.deployedPath = linkPath;
+        if (fs5.existsSync(linkPath) && !options?.force) {
+          const stat = fs5.lstatSync(linkPath);
+          if (stat.isSymbolicLink()) {
+            const existingTarget = fs5.readlinkSync(linkPath);
+            const resolvedTarget = path5.resolve(path5.dirname(linkPath), existingTarget);
+            if (resolvedTarget === sourcePath) {
+              result.success = true;
+              return result;
+            }
+          }
+          result.error = `Skill already exists at ${linkPath}. Use --force to overwrite.`;
+          return result;
+        }
+        const symlinkResult = await createSymlinkSafe(sourcePath, linkPath);
+        if (!symlinkResult.success) {
+          result.error = symlinkResult.error;
+          return result;
+        }
+        result.success = true;
+        logger.info(`Deployed ${skillName} to ${agent.displayName}: ${linkPath} -> ${sourcePath}`);
+        return result;
+      }
+      async remove(skillName, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          removedPath: null
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path5.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.error = `Agent ${agent.displayName} has no skills directory configured`;
+          return result;
+        }
+        const linkPath = path5.join(targetDir, skillName);
+        result.removedPath = linkPath;
+        try {
+          if (!fs5.existsSync(linkPath)) {
+            result.success = true;
+            return result;
+          }
+          const stat = fs5.lstatSync(linkPath);
+          if (!stat.isSymbolicLink()) {
+            result.error = `Path is not a symlink: ${linkPath}`;
+            return result;
+          }
+          fs5.unlinkSync(linkPath);
+          result.success = true;
+          logger.info(`Removed ${skillName} from ${agent.displayName}: ${linkPath}`);
+        } catch (err) {
+          result.error = err.message;
+        }
+        return result;
+      }
+      async list(agent, options) {
+        const results = [];
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path5.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir || !fs5.existsSync(targetDir)) {
+          return results;
+        }
+        try {
+          const entries = fs5.readdirSync(targetDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path5.join(targetDir, entry.name);
+            try {
+              const stat = fs5.lstatSync(fullPath);
+              if (stat.isSymbolicLink()) {
+                const target = fs5.readlinkSync(fullPath);
+                const resolvedTarget = path5.resolve(path5.dirname(fullPath), target);
+                const isValid2 = fs5.existsSync(resolvedTarget);
+                results.push({
+                  name: entry.name,
+                  agent: agent.name,
+                  path: fullPath,
+                  isValid: isValid2,
+                  target: resolvedTarget,
+                  isSymlink: true
+                });
+              } else if (stat.isDirectory()) {
+                const skillMdPath = path5.join(fullPath, "SKILL.md");
+                results.push({
+                  name: entry.name,
+                  agent: agent.name,
+                  path: fullPath,
+                  isValid: fs5.existsSync(skillMdPath),
+                  isSymlink: false
+                });
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+        return results;
+      }
+      async isDeployed(skillName, agent, options) {
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path5.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          return { deployed: false, valid: false };
+        }
+        const linkPath = path5.join(targetDir, skillName);
+        try {
+          if (!fs5.existsSync(linkPath)) {
+            return { deployed: false, valid: false };
+          }
+          const stat = fs5.lstatSync(linkPath);
+          if (!stat.isSymbolicLink()) {
+            const skillMdPath = path5.join(linkPath, "SKILL.md");
+            return {
+              deployed: true,
+              valid: fs5.existsSync(skillMdPath),
+              path: linkPath
+            };
+          }
+          const target = fs5.readlinkSync(linkPath);
+          const resolvedTarget = path5.resolve(path5.dirname(linkPath), target);
+          const isValid2 = fs5.existsSync(resolvedTarget);
+          return {
+            deployed: true,
+            valid: isValid2,
+            path: linkPath
+          };
+        } catch {
+          return { deployed: false, valid: false };
+        }
+      }
+    };
+    symlinkAdapter = new SymlinkAdapter();
+  }
+});
+
+// src/platform/format-converter.ts
+function convertToMdc(skill) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`description: "${skill.description.replace(/"/g, '\\"')}"`);
+  lines.push("globs:");
+  lines.push("alwaysApply: false");
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${skill.displayName || formatSkillName(skill.name)}`);
+  lines.push("");
+  lines.push(skill.description);
+  lines.push("");
+  lines.push(skill.body);
+  if (skill.skillId || skill.workflowId) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Refly Skill");
+    lines.push("");
+    if (skill.skillId) {
+      lines.push(`- **Skill ID**: ${skill.skillId}`);
+    }
+    if (skill.workflowId) {
+      lines.push(`- **Workflow ID**: ${skill.workflowId}`);
+    }
+    if (skill.installationId) {
+      lines.push(`- **Installation ID**: ${skill.installationId}`);
+    }
+    const runId = skill.installationId || skill.workflowId || skill.name;
+    lines.push(`- **Run**: \`refly skill run ${runId}\``);
+  }
+  return lines.join("\n");
+}
+function convertToRules(skill) {
+  const lines = [];
+  lines.push(`# ${skill.displayName || formatSkillName(skill.name)}`);
+  lines.push("");
+  lines.push(`> ${skill.description}`);
+  lines.push("");
+  if (skill.triggers && skill.triggers.length > 0) {
+    lines.push("## Triggers");
+    lines.push("");
+    for (const trigger of skill.triggers) {
+      lines.push(`- ${trigger}`);
+    }
+    lines.push("");
+  }
+  lines.push(skill.body);
+  if (skill.skillId || skill.workflowId) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Refly Skill");
+    lines.push("");
+    if (skill.skillId) {
+      lines.push(`- **Skill ID**: ${skill.skillId}`);
+    }
+    if (skill.workflowId) {
+      lines.push(`- **Workflow ID**: ${skill.workflowId}`);
+    }
+    if (skill.installationId) {
+      lines.push(`- **Installation ID**: ${skill.installationId}`);
+    }
+    const runId = skill.installationId || skill.workflowId || skill.name;
+    lines.push(`- **Run**: \`refly skill run ${runId}\``);
+  }
+  return lines.join("\n");
+}
+function formatSkillName(name) {
+  return name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function parseSkillMdLenient(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return null;
+  }
+  const [, frontmatterStr, body] = match;
+  const meta = {};
+  const lines = frontmatterStr.split("\n");
+  let currentKey = null;
+  let currentArray = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      if (currentKey) {
+        currentArray.push(trimmed.slice(2).trim());
+      }
+      continue;
+    }
+    if (currentKey && currentArray.length > 0) {
+      meta[currentKey] = currentArray;
+      currentArray = [];
+      currentKey = null;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      const value = trimmed.slice(colonIndex + 1).trim();
+      if (value === "") {
+        currentKey = key;
+        currentArray = [];
+      } else {
+        meta[key] = value;
+      }
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    meta[currentKey] = currentArray;
+  }
+  if (!meta.name || !meta.description) {
+    return null;
+  }
+  return {
+    name: meta.name,
+    displayName: meta.displayName,
+    description: meta.description,
+    skillId: meta.skillId,
+    workflowId: meta.workflowId,
+    installationId: meta.installationId,
+    triggers: meta.triggers,
+    tags: meta.tags,
+    version: meta.version,
+    body: body.trim()
+  };
+}
+function readSkillMd(sourcePath) {
+  const skillMdPath = path6.join(sourcePath, "SKILL.md");
+  if (!fs6.existsSync(skillMdPath)) {
+    return null;
+  }
+  try {
+    const content = fs6.readFileSync(skillMdPath, "utf-8");
+    return parseSkillMdLenient(content);
+  } catch {
+    return null;
+  }
+}
+var fs6, path6, FormatConverterAdapter, formatConverterAdapter;
+var init_format_converter = __esm({
+  "src/platform/format-converter.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    init_logger();
+    init_paths();
+    FormatConverterAdapter = class {
+      async deploy(skillName, sourcePath, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          deployedPath: null,
+          sourcePath,
+          isSymlink: false
+          // We generate files, not symlinks
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.success = true;
+          logger.debug(`Skipping ${skillName} for ${agent.displayName}: no global skills directory`);
+          return result;
+        }
+        const skill = readSkillMd(sourcePath);
+        if (!skill) {
+          result.error = `Failed to read SKILL.md from ${sourcePath}`;
+          return result;
+        }
+        const extension = agent.fileExtension || ".md";
+        const filePath = path6.join(targetDir, `${skillName}${extension}`);
+        result.deployedPath = filePath;
+        if (fs6.existsSync(filePath) && !options?.force) {
+          result.error = `Skill already exists at ${filePath}. Use --force to overwrite.`;
+          return result;
+        }
+        let content;
+        switch (agent.format) {
+          case "cursor-mdc":
+            content = convertToMdc(skill);
+            break;
+          case "rules-md":
+            content = convertToRules(skill);
+            break;
+          default:
+            result.error = `Unsupported format: ${agent.format}`;
+            return result;
+        }
+        try {
+          ensureDir(targetDir);
+          fs6.writeFileSync(filePath, content, { encoding: "utf-8", mode: 420 });
+          result.success = true;
+          logger.info(`Deployed ${skillName} to ${agent.displayName}: ${filePath}`);
+        } catch (err) {
+          result.error = err.message;
+        }
+        return result;
+      }
+      async remove(skillName, agent, options) {
+        const result = {
+          success: false,
+          agent: agent.name,
+          skillName,
+          removedPath: null
+        };
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          result.success = true;
+          logger.debug(
+            `Skipping ${skillName} removal for ${agent.displayName}: no global skills directory`
+          );
+          return result;
+        }
+        const extension = agent.fileExtension || ".md";
+        const filePath = path6.join(targetDir, `${skillName}${extension}`);
+        result.removedPath = filePath;
+        try {
+          if (!fs6.existsSync(filePath)) {
+            result.success = true;
+            return result;
+          }
+          fs6.unlinkSync(filePath);
+          result.success = true;
+          logger.info(`Removed ${skillName} from ${agent.displayName}: ${filePath}`);
+        } catch (err) {
+          result.error = err.message;
+        }
+        return result;
+      }
+      async list(agent, options) {
+        const results = [];
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir || !fs6.existsSync(targetDir)) {
+          return results;
+        }
+        const extension = agent.fileExtension || ".md";
+        try {
+          const entries = fs6.readdirSync(targetDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith(extension)) {
+              const fullPath = path6.join(targetDir, entry.name);
+              const skillName = entry.name.slice(0, -extension.length);
+              let isReflySkill = false;
+              try {
+                const content = fs6.readFileSync(fullPath, "utf-8");
+                isReflySkill = content.includes("## Refly Skill") || content.includes("Skill ID:");
+              } catch {
+              }
+              results.push({
+                name: skillName,
+                agent: agent.name,
+                path: fullPath,
+                isValid: isReflySkill,
+                isSymlink: false
+              });
+            }
+          }
+        } catch {
+        }
+        return results;
+      }
+      async isDeployed(skillName, agent, options) {
+        let targetDir = null;
+        if (options?.projectPath && agent.skillsDir) {
+          targetDir = path6.join(options.projectPath, agent.skillsDir);
+        } else {
+          targetDir = agent.globalSkillsDir;
+        }
+        if (!targetDir) {
+          return { deployed: false, valid: false };
+        }
+        const extension = agent.fileExtension || ".md";
+        const filePath = path6.join(targetDir, `${skillName}${extension}`);
+        if (!fs6.existsSync(filePath)) {
+          return { deployed: false, valid: false };
+        }
+        let isValid2 = false;
+        try {
+          const content = fs6.readFileSync(filePath, "utf-8");
+          isValid2 = content.includes("## Refly Skill") || content.includes("Skill ID:");
+        } catch {
+        }
+        return {
+          deployed: true,
+          valid: isValid2,
+          path: filePath
+        };
+      }
+    };
+    formatConverterAdapter = new FormatConverterAdapter();
+  }
+});
+
+// src/platform/manager.ts
+function getAdapter(agent) {
+  switch (agent.format) {
+    case "skill-md":
+      return symlinkAdapter;
+    case "cursor-mdc":
+    case "rules-md":
+      return formatConverterAdapter;
+    default:
+      return symlinkAdapter;
+  }
+}
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const agent of Object.values(agents)) {
+    try {
+      const isInstalled = await agent.detectInstalled();
+      if (isInstalled) {
+        installed.push(agent);
+      }
+    } catch (err) {
+      logger.debug(`Error detecting ${agent.displayName}: ${err.message}`);
+    }
+  }
+  return installed;
+}
+async function getDeployableAgents(options) {
+  const installed = await detectInstalledAgents();
+  if (options?.includeUnknown) {
+    return installed;
+  }
+  return installed.filter((agent) => agent.format !== "unknown");
+}
+async function deploySkillToAllPlatforms(skillName, options) {
+  const sourcePath = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
+  const result = {
+    skillName,
+    sourcePath,
+    results: /* @__PURE__ */ new Map(),
+    successCount: 0,
+    failureCount: 0
+  };
+  if (!fs7.existsSync(sourcePath)) {
+    logger.error(`Source skill directory does not exist: ${sourcePath}`);
+    return result;
+  }
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const deployResult = await adapter.deploy(skillName, sourcePath, agent, {
+        force: options?.force,
+        projectPath: options?.projectPath
+      });
+      result.results.set(agent.name, deployResult);
+      if (deployResult.success) {
+        result.successCount++;
+      } else {
+        result.failureCount++;
+      }
+    } catch (err) {
+      result.results.set(agent.name, {
+        success: false,
+        agent: agent.name,
+        skillName,
+        deployedPath: null,
+        sourcePath,
+        isSymlink: false,
+        error: err.message
+      });
+      result.failureCount++;
+    }
+  }
+  return result;
+}
+async function removeSkillFromAllPlatforms(skillName, options) {
+  const result = {
+    skillName,
+    results: /* @__PURE__ */ new Map(),
+    successCount: 0,
+    failureCount: 0
+  };
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const removeResult = await adapter.remove(skillName, agent, {
+        projectPath: options?.projectPath
+      });
+      result.results.set(agent.name, removeResult);
+      if (removeResult.success) {
+        result.successCount++;
+      } else {
+        result.failureCount++;
+      }
+    } catch (err) {
+      result.results.set(agent.name, {
+        success: false,
+        agent: agent.name,
+        skillName,
+        removedPath: null,
+        error: err.message
+      });
+      result.failureCount++;
+    }
+  }
+  return result;
+}
+async function listAllDeployedSkills(options) {
+  const result = /* @__PURE__ */ new Map();
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const skills = await adapter.list(agent, {
+        projectPath: options?.projectPath
+      });
+      result.set(agent.name, skills);
+    } catch (err) {
+      logger.debug(`Error listing skills for ${agent.displayName}: ${err.message}`);
+      result.set(agent.name, []);
+    }
+  }
+  return result;
+}
+async function syncSkillToAllPlatforms(skillName, options) {
+  const needsSync = /* @__PURE__ */ new Map();
+  const synced = /* @__PURE__ */ new Map();
+  const sourcePath = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
+  let targetAgents;
+  if (options?.agents && options.agents.length > 0) {
+    targetAgents = options.agents.map((name) => agents[name]).filter(Boolean);
+  } else {
+    targetAgents = await getDeployableAgents();
+  }
+  for (const agent of targetAgents) {
+    const adapter = getAdapter(agent);
+    try {
+      const status = await adapter.isDeployed(skillName, agent, {
+        projectPath: options?.projectPath
+      });
+      needsSync.set(agent.name, status);
+      if ((!status.deployed || !status.valid) && !options?.dryRun) {
+        const deployResult = await adapter.deploy(skillName, sourcePath, agent, {
+          force: true,
+          // Force to repair
+          projectPath: options?.projectPath
+        });
+        synced.set(agent.name, deployResult);
+      }
+    } catch (err) {
+      logger.debug(
+        `Error checking/syncing ${skillName} for ${agent.displayName}: ${err.message}`
+      );
+    }
+  }
+  return { needsSync, synced };
+}
+var fs7;
+var init_manager = __esm({
+  "src/platform/manager.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs7 = __toESM(require("fs"));
+    init_registry();
+    init_symlink_adapter();
+    init_format_converter();
+    init_paths();
+    init_logger();
+  }
+});
+
 // src/skill/symlink.ts
 var symlink_exports = {};
 __export(symlink_exports, {
+  createMultiPlatformSkill: () => createMultiPlatformSkill,
   createReflySkillWithSymlink: () => createReflySkillWithSymlink,
   createSkillSymlink: () => createSkillSymlink,
   deleteDomainSkillWithSymlink: () => deleteDomainSkillWithSymlink,
   generateReflySkillMd: () => generateReflySkillMd,
   initializeBaseSkillSymlink: () => initializeBaseSkillSymlink,
   isSkillSymlinkValid: () => isSkillSymlinkValid,
+  listMultiPlatformSkills: () => listMultiPlatformSkills,
   listSkillSymlinks: () => listSkillSymlinks,
   parseReflySkillMd: () => parseReflySkillMd,
+  removeMultiPlatformSkill: () => removeMultiPlatformSkill,
   removeSkillSymlink: () => removeSkillSymlink
 });
 function createSkillSymlink(skillName) {
@@ -3279,7 +4127,7 @@ function createSkillSymlink(skillName) {
   try {
     ensureReflySkillsDir();
     ensureClaudeSkillsDir();
-    if (!fs4.existsSync(reflyPath)) {
+    if (!fs8.existsSync(reflyPath)) {
       return {
         success: false,
         skillName,
@@ -3288,10 +4136,10 @@ function createSkillSymlink(skillName) {
         error: `Source skill directory does not exist: ${reflyPath}`
       };
     }
-    if (fs4.existsSync(claudePath) || fs4.lstatSync(claudePath).isSymbolicLink()) {
-      const stat = fs4.lstatSync(claudePath);
+    if (fs8.existsSync(claudePath) || fs8.lstatSync(claudePath).isSymbolicLink()) {
+      const stat = fs8.lstatSync(claudePath);
       if (stat.isSymbolicLink()) {
-        fs4.unlinkSync(claudePath);
+        fs8.unlinkSync(claudePath);
         logger.debug(`Removed existing symlink: ${claudePath}`);
       } else if (stat.isDirectory()) {
         logger.warn(`Cannot create symlink: ${claudePath} is a directory, not a symlink`);
@@ -3304,7 +4152,7 @@ function createSkillSymlink(skillName) {
         };
       }
     }
-    fs4.symlinkSync(reflyPath, claudePath, "dir");
+    fs8.symlinkSync(reflyPath, claudePath, "dir");
     logger.info(`Created symlink: ${claudePath} -> ${reflyPath}`);
     return {
       success: true,
@@ -3315,7 +4163,7 @@ function createSkillSymlink(skillName) {
   } catch (err) {
     if (err.code === "ENOENT") {
       try {
-        fs4.symlinkSync(reflyPath, claudePath, "dir");
+        fs8.symlinkSync(reflyPath, claudePath, "dir");
         logger.info(`Created symlink: ${claudePath} -> ${reflyPath}`);
         return {
           success: true,
@@ -3345,16 +4193,16 @@ function createSkillSymlink(skillName) {
 function removeSkillSymlink(skillName) {
   const claudePath = getClaudeSkillSymlinkPath(skillName);
   try {
-    if (!fs4.existsSync(claudePath)) {
+    if (!fs8.existsSync(claudePath)) {
       logger.debug(`Symlink not found: ${claudePath}`);
       return false;
     }
-    const stat = fs4.lstatSync(claudePath);
+    const stat = fs8.lstatSync(claudePath);
     if (!stat.isSymbolicLink()) {
       logger.warn(`Not a symlink: ${claudePath}`);
       return false;
     }
-    fs4.unlinkSync(claudePath);
+    fs8.unlinkSync(claudePath);
     logger.info(`Removed symlink: ${claudePath}`);
     return true;
   } catch (err) {
@@ -3366,16 +4214,16 @@ function isSkillSymlinkValid(skillName) {
   const claudePath = getClaudeSkillSymlinkPath(skillName);
   const expectedTarget = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
   try {
-    if (!fs4.existsSync(claudePath)) {
+    if (!fs8.existsSync(claudePath)) {
       return { exists: false, isSymlink: false, isValid: false };
     }
-    const stat = fs4.lstatSync(claudePath);
+    const stat = fs8.lstatSync(claudePath);
     if (!stat.isSymbolicLink()) {
       return { exists: true, isSymlink: false, isValid: false };
     }
-    const target = fs4.readlinkSync(claudePath);
-    const resolvedTarget = path4.resolve(path4.dirname(claudePath), target);
-    const isValid2 = resolvedTarget === expectedTarget && fs4.existsSync(resolvedTarget);
+    const target = fs8.readlinkSync(claudePath);
+    const resolvedTarget = path7.resolve(path7.dirname(claudePath), target);
+    const isValid2 = resolvedTarget === expectedTarget && fs8.existsSync(resolvedTarget);
     return {
       exists: true,
       isSymlink: true,
@@ -3389,17 +4237,17 @@ function isSkillSymlinkValid(skillName) {
 function initializeBaseSkillSymlink() {
   const baseDir = getReflyBaseSkillDir();
   ensureDir(baseDir);
-  ensureDir(path4.join(baseDir, "rules"));
+  ensureDir(path7.join(baseDir, "rules"));
   return createSkillSymlink("refly");
 }
 function createReflySkillWithSymlink(skillName, skillMdContent, options) {
   const skillDir = getReflyDomainSkillDir(skillName);
   try {
     ensureReflySkillsDir();
-    if (fs4.existsSync(skillDir)) {
+    if (fs8.existsSync(skillDir)) {
       if (options?.force) {
-        const skillMdPath2 = path4.join(skillDir, "SKILL.md");
-        fs4.writeFileSync(skillMdPath2, skillMdContent, { encoding: "utf-8", mode: 420 });
+        const skillMdPath2 = path7.join(skillDir, "SKILL.md");
+        fs8.writeFileSync(skillMdPath2, skillMdContent, { encoding: "utf-8", mode: 420 });
         logger.debug(`Updated SKILL.md (force): ${skillMdPath2}`);
         return createSkillSymlink(skillName);
       }
@@ -3411,9 +4259,9 @@ function createReflySkillWithSymlink(skillName, skillMdContent, options) {
         error: `Skill directory already exists: ${skillDir}`
       };
     }
-    fs4.mkdirSync(skillDir, { recursive: true, mode: 493 });
-    const skillMdPath = path4.join(skillDir, "SKILL.md");
-    fs4.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+    fs8.mkdirSync(skillDir, { recursive: true, mode: 493 });
+    const skillMdPath = path7.join(skillDir, "SKILL.md");
+    fs8.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
     logger.debug(`Created SKILL.md: ${skillMdPath}`);
     return createSkillSymlink(skillName);
   } catch (err) {
@@ -3431,8 +4279,8 @@ function deleteDomainSkillWithSymlink(skillName) {
   const skillDir = getReflyDomainSkillDir(skillName);
   let directoryRemoved = false;
   try {
-    if (fs4.existsSync(skillDir)) {
-      fs4.rmSync(skillDir, { recursive: true, force: true });
+    if (fs8.existsSync(skillDir)) {
+      fs8.rmSync(skillDir, { recursive: true, force: true });
       directoryRemoved = true;
       logger.info(`Removed skill directory: ${skillDir}`);
     }
@@ -3444,19 +4292,19 @@ function deleteDomainSkillWithSymlink(skillName) {
 function listSkillSymlinks() {
   const claudeSkillsDir = getClaudeSkillsDir();
   const results = [];
-  if (!fs4.existsSync(claudeSkillsDir)) {
+  if (!fs8.existsSync(claudeSkillsDir)) {
     return results;
   }
   try {
-    const entries = fs4.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(claudeSkillsDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path4.join(claudeSkillsDir, entry.name);
+      const fullPath = path7.join(claudeSkillsDir, entry.name);
       try {
-        const stat = fs4.lstatSync(fullPath);
+        const stat = fs8.lstatSync(fullPath);
         if (stat.isSymbolicLink()) {
-          const target = fs4.readlinkSync(fullPath);
-          const resolvedTarget = path4.resolve(path4.dirname(fullPath), target);
-          const isValid2 = fs4.existsSync(resolvedTarget);
+          const target = fs8.readlinkSync(fullPath);
+          const resolvedTarget = path7.resolve(path7.dirname(fullPath), target);
+          const isValid2 = fs8.existsSync(resolvedTarget);
           results.push({
             name: entry.name,
             claudePath: fullPath,
@@ -3471,6 +4319,12 @@ function listSkillSymlinks() {
   }
   return results;
 }
+function escapeYamlValue(value) {
+  if (value.includes(":") || value.includes("#") || value.includes("'") || value.includes('"') || value.includes("\n") || value.startsWith(" ") || value.endsWith(" ") || value.startsWith("[") || value.startsWith("{")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
 function generateReflySkillMd(options) {
   const {
     name,
@@ -3485,21 +4339,21 @@ function generateReflySkillMd(options) {
     inputSchema,
     outputSchema
   } = options;
-  const frontmatterLines = ["---", `name: ${name}`];
-  frontmatterLines.push(`description: ${description}`);
+  const frontmatterLines = ["---", `name: ${escapeYamlValue(name)}`];
+  frontmatterLines.push(`description: ${escapeYamlValue(description)}`);
   if (tags.length > 0) {
     frontmatterLines.push("tags:");
-    frontmatterLines.push(...tags.map((t) => `  - ${t}`));
+    frontmatterLines.push(...tags.map((t) => `  - ${escapeYamlValue(t)}`));
   }
-  frontmatterLines.push(`version: ${version}`);
-  frontmatterLines.push(`skillId: ${skillId}`);
-  frontmatterLines.push(`workflowId: ${workflowId}`);
+  frontmatterLines.push(`version: ${escapeYamlValue(version)}`);
+  frontmatterLines.push(`skillId: ${escapeYamlValue(skillId)}`);
+  frontmatterLines.push(`workflowId: ${escapeYamlValue(workflowId)}`);
   if (installationId) {
-    frontmatterLines.push(`installationId: ${installationId}`);
+    frontmatterLines.push(`installationId: ${escapeYamlValue(installationId)}`);
   }
   if (triggers.length > 0) {
     frontmatterLines.push("triggers:");
-    frontmatterLines.push(...triggers.map((t) => `  - ${t}`));
+    frontmatterLines.push(...triggers.map((t) => `  - ${escapeYamlValue(t)}`));
   }
   frontmatterLines.push("---");
   const title = displayName || name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -3518,14 +4372,6 @@ ${JSON.stringify(outputSchema, null, 2)}
 
 ${description}
 
-## Usage
-
-This skill is executed via Refly CLI:
-
-\`\`\`bash
-${runCommand}
-\`\`\`
-
 ## Input
 
 Provide input as JSON:
@@ -3534,16 +4380,42 @@ Provide input as JSON:
 ${inputExample}
 \`\`\`
 
+## Execution
+
+**Follow this exact 4-step pattern:**
+
+\`\`\`bash
+# Step 1: Run and capture RUN_ID (we-xxx format)
+RESULT=$(${runCommand})
+RUN_ID=$(echo "$RESULT" | jq -r '.payload.workflowExecutions[0].id')
+# RUN_ID is we-xxx format, use this for workflow commands below
+
+# Step 2: Wait for completion (use RUN_ID, not installationId)
+refly workflow status "$RUN_ID" --watch --interval 30000
+
+# Step 3: Get files from this run (use RUN_ID)
+FILES=$(refly workflow toolcalls "$RUN_ID" --files --latest | jq -r '.payload.files[]')
+
+# Step 4: Download and open each file
+echo "$FILES" | jq -c '.' | while read -r file; do
+  FILE_ID=$(echo "$file" | jq -r '.fileId')
+  FILE_NAME=$(echo "$file" | jq -r '.name')
+  if [ -n "$FILE_ID" ] && [ "$FILE_ID" != "null" ]; then
+    OUTPUT_PATH="$HOME/Desktop/$FILE_NAME"
+    refly file download "$FILE_ID" -o "$OUTPUT_PATH"
+    open "$OUTPUT_PATH"
+  fi
+done
+\`\`\`
+
 ## Output
 
 ${outputSection}
 
 ## Rules
 
-For workflow operations, refer to the base skill rules:
-- Workflow: \`~/.claude/skills/refly/rules/workflow.md\`
-- Node: \`~/.claude/skills/refly/rules/node.md\`
-- File: \`~/.claude/skills/refly/rules/file.md\`
+For workflow operations, refer to the base skill:
+- Base skill: \`~/.claude/skills/refly/SKILL.md\`
 `;
   return frontmatterLines.join("\n") + content;
 }
@@ -3604,15 +4476,79 @@ function parseReflySkillMd(content) {
     raw: content
   };
 }
-var fs4, path4;
+async function createMultiPlatformSkill(skillName, skillMdContent, options) {
+  const skillDir = getReflyDomainSkillDir(skillName);
+  ensureReflySkillsDir();
+  if (fs8.existsSync(skillDir)) {
+    if (options?.force) {
+      const skillMdPath = path7.join(skillDir, "SKILL.md");
+      fs8.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+      logger.debug(`Updated SKILL.md (force): ${skillMdPath}`);
+    } else {
+      return {
+        skillName,
+        sourcePath: skillDir,
+        results: /* @__PURE__ */ new Map(),
+        successCount: 0,
+        failureCount: 1
+      };
+    }
+  } else {
+    fs8.mkdirSync(skillDir, { recursive: true, mode: 493 });
+    const skillMdPath = path7.join(skillDir, "SKILL.md");
+    fs8.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+    logger.debug(`Created SKILL.md: ${skillMdPath}`);
+  }
+  return deploySkillToAllPlatforms(skillName, {
+    force: options?.force,
+    agents: options?.agents
+  });
+}
+async function removeMultiPlatformSkill(skillName, options) {
+  const platformResults = await removeSkillFromAllPlatforms(skillName, {
+    agents: options?.agents
+  });
+  let directoryRemoved = false;
+  if (!options?.keepLocal) {
+    const skillDir = getReflyDomainSkillDir(skillName);
+    try {
+      if (fs8.existsSync(skillDir)) {
+        fs8.rmSync(skillDir, { recursive: true, force: true });
+        directoryRemoved = true;
+        logger.info(`Removed skill directory: ${skillDir}`);
+      }
+    } catch (err) {
+      logger.error(`Failed to remove skill directory ${skillDir}:`, err);
+    }
+  }
+  return { platformResults, directoryRemoved };
+}
+async function listMultiPlatformSkills(options) {
+  const allDeployed = await listAllDeployedSkills({ agents: options?.agents });
+  const result = /* @__PURE__ */ new Map();
+  for (const [agent, skills] of allDeployed) {
+    result.set(
+      agent,
+      skills.map((s) => ({
+        name: s.name,
+        path: s.path,
+        isValid: s.isValid,
+        isSymlink: s.isSymlink
+      }))
+    );
+  }
+  return result;
+}
+var fs8, path7;
 var init_symlink = __esm({
   "src/skill/symlink.ts"() {
     "use strict";
     init_cjs_shims();
-    fs4 = __toESM(require("fs"));
-    path4 = __toESM(require("path"));
+    fs8 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
     init_paths();
     init_logger();
+    init_manager();
   }
 });
 
@@ -4303,8 +5239,21 @@ var OutputFormatter = class {
   }
   // === JSON Format ===
   outputJson(data) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data, this.sanitizeJsonReplacer, 2));
   }
+  /**
+   * JSON replacer that sanitizes control characters in strings.
+   * Control characters (U+0000 to U+001F) can break jq parsing.
+   */
+  sanitizeJsonReplacer = (_key, value) => {
+    if (typeof value === "string") {
+      return value.split("").filter((char) => {
+        const code = char.charCodeAt(0);
+        return code >= 32 || code === 9 || code === 10 || code === 13;
+      }).join("");
+    }
+    return value;
+  };
   // === Pretty Format ===
   outputPretty(type, payload) {
     if (type === "workflow.status" || type === "workflow.progress") {
@@ -4893,8 +5842,8 @@ var ErrorCodes = {
 };
 
 // src/bin/refly.ts
-var fs26 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 
 // src/commands/init.ts
 init_cjs_shims();
@@ -5399,8 +6348,8 @@ function getErrorMap() {
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 init_cjs_shims();
 var makeIssue = (params) => {
-  const { data, path: path22, errorMaps, issueData } = params;
-  const fullPath = [...path22, ...issueData.path || []];
+  const { data, path: path25, errorMaps, issueData } = params;
+  const fullPath = [...path25, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5520,11 +6469,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path22, key) {
+  constructor(parent, value, path25, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path22;
+    this._path = path25;
     this._key = key;
   }
   get path() {
@@ -8968,6 +9917,23 @@ var NEVER = INVALID;
 
 // src/config/config.ts
 init_paths();
+var AgentTypeEnum = external_exports.enum([
+  "claude-code",
+  "codex",
+  "antigravity",
+  "github-copilot",
+  "windsurf",
+  "opencode",
+  "moltbot",
+  "cursor",
+  "continue",
+  "trae",
+  "qoder"
+]);
+var PlatformConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  globalPath: external_exports.string().optional()
+});
 var ConfigSchema = external_exports.object({
   version: external_exports.number().default(1),
   auth: external_exports.object({
@@ -8995,7 +9961,9 @@ var ConfigSchema = external_exports.object({
   skill: external_exports.object({
     installedVersion: external_exports.string().optional(),
     installedAt: external_exports.string().optional()
-  }).optional()
+  }).optional(),
+  // Multi-platform configuration
+  platforms: external_exports.record(AgentTypeEnum, PlatformConfigSchema).optional()
 });
 var DEFAULT_API_ENDPOINT = "https://api.refly.ai";
 var DEFAULT_WEB_URL = "https://refly.ai";
@@ -9132,22 +10100,22 @@ init_paths();
 
 // src/skill/installer.ts
 init_cjs_shims();
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 init_paths();
 init_logger();
 init_symlink();
 function removeOldSkillDirectory() {
   const claudeSkillPath = getClaudeSkillSymlinkPath("refly");
-  if (!fs5.existsSync(claudeSkillPath)) {
+  if (!fs9.existsSync(claudeSkillPath)) {
     return;
   }
   try {
-    const stat = fs5.lstatSync(claudeSkillPath);
+    const stat = fs9.lstatSync(claudeSkillPath);
     if (stat.isSymbolicLink()) {
-      fs5.unlinkSync(claudeSkillPath);
+      fs9.unlinkSync(claudeSkillPath);
     } else if (stat.isDirectory()) {
-      fs5.rmSync(claudeSkillPath, { recursive: true, force: true });
+      fs9.rmSync(claudeSkillPath, { recursive: true, force: true });
       logger.info("Removed old skill directory");
     }
   } catch (err) {
@@ -9156,17 +10124,17 @@ function removeOldSkillDirectory() {
 }
 function getPackageSkillDir() {
   const possiblePaths = [
-    path5.join(__dirname, "..", "..", "skill"),
+    path8.join(__dirname, "..", "..", "skill"),
     // Built package: dist/bin/../../skill
-    path5.join(__dirname, "..", "..", "..", "skill"),
+    path8.join(__dirname, "..", "..", "..", "skill"),
     // Development: dist/bin/../../../skill
-    path5.join(__dirname, "..", "skill")
+    path8.join(__dirname, "..", "skill")
     // Alternative: dist/../skill
   ];
   logger.debug("Looking for skill files, __dirname:", __dirname);
   for (const p of possiblePaths) {
-    const resolved = path5.resolve(p);
-    const exists = fs5.existsSync(resolved);
+    const resolved = path8.resolve(p);
+    const exists = fs9.existsSync(resolved);
     logger.debug(`  Checking path: ${resolved} - exists: ${exists}`);
     if (exists) {
       return resolved;
@@ -9190,30 +10158,30 @@ function installSkill() {
   logger.debug("Target skill directory:", targetDir);
   try {
     ensureDir(targetDir);
-    ensureDir(path5.join(targetDir, "rules"));
+    ensureDir(path8.join(targetDir, "rules"));
     logger.debug("Created target directories");
   } catch (err) {
     logger.error("Failed to create target directories:", err);
     throw err;
   }
-  const skillSource = path5.join(sourceDir, "SKILL.md");
-  const skillTarget = path5.join(targetDir, "SKILL.md");
+  const skillSource = path8.join(sourceDir, "SKILL.md");
+  const skillTarget = path8.join(targetDir, "SKILL.md");
   logger.debug(`Copying SKILL.md: ${skillSource} -> ${skillTarget}`);
-  if (fs5.existsSync(skillSource)) {
-    fs5.copyFileSync(skillSource, skillTarget);
+  if (fs9.existsSync(skillSource)) {
+    fs9.copyFileSync(skillSource, skillTarget);
     result.skillInstalled = true;
     result.skillPath = targetDir;
     logger.debug("SKILL.md copied successfully");
   } else {
     logger.warn("SKILL.md source not found:", skillSource);
   }
-  const refsSource = path5.join(sourceDir, "references");
-  const rulesTarget = path5.join(targetDir, "rules");
-  if (fs5.existsSync(refsSource)) {
-    const files = fs5.readdirSync(refsSource);
+  const refsSource = path8.join(sourceDir, "references");
+  const rulesTarget = path8.join(targetDir, "rules");
+  if (fs9.existsSync(refsSource)) {
+    const files = fs9.readdirSync(refsSource);
     logger.debug(`Copying ${files.length} rule files`);
     for (const file of files) {
-      fs5.copyFileSync(path5.join(refsSource, file), path5.join(rulesTarget, file));
+      fs9.copyFileSync(path8.join(refsSource, file), path8.join(rulesTarget, file));
     }
   }
   removeOldSkillDirectory();
@@ -9241,15 +10209,15 @@ function installSkill() {
   return result;
 }
 function installSlashCommands(sourceDir, targetDir) {
-  const commandsSource = path5.join(sourceDir, "..", "commands");
-  if (!fs5.existsSync(commandsSource)) {
+  const commandsSource = path8.join(sourceDir, "..", "commands");
+  if (!fs9.existsSync(commandsSource)) {
     return false;
   }
   try {
-    const files = fs5.readdirSync(commandsSource);
+    const files = fs9.readdirSync(commandsSource);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        fs5.copyFileSync(path5.join(commandsSource, file), path5.join(targetDir, file));
+        fs9.copyFileSync(path8.join(commandsSource, file), path8.join(targetDir, file));
       }
     }
     return files.length > 0;
@@ -9259,8 +10227,8 @@ function installSlashCommands(sourceDir, targetDir) {
 }
 function getSkillVersion() {
   try {
-    const skillPath = path5.join(getPackageSkillDir(), "SKILL.md");
-    const content = fs5.readFileSync(skillPath, "utf-8");
+    const skillPath = path8.join(getPackageSkillDir(), "SKILL.md");
+    const content = fs9.readFileSync(skillPath, "utf-8");
     const versionMatch = content.match(/version:\s*(\d+\.\d+\.\d+)/);
     if (versionMatch) {
       return versionMatch[1];
@@ -9268,16 +10236,16 @@ function getSkillVersion() {
   } catch {
   }
   try {
-    const pkgPath = path5.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path8.join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.1.0";
   }
 }
 function isSkillInstalled() {
-  const skillPath = path5.join(getReflyBaseSkillDir(), "SKILL.md");
-  if (!fs5.existsSync(skillPath)) {
+  const skillPath = path8.join(getReflyBaseSkillDir(), "SKILL.md");
+  if (!fs9.existsSync(skillPath)) {
     return { installed: false, upToDate: false };
   }
   const currentVersion = getSkillVersion();
@@ -9291,6 +10259,9 @@ function isSkillInstalled() {
   };
 }
 
+// src/commands/init.ts
+init_manager();
+
 // src/utils/logo.ts
 init_cjs_shims();
 var REFLY_LOGO = `\u2588\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588   \u2588 \u2588   \u2588\u2580\u2588 \u2588
@@ -9349,7 +10320,7 @@ var import_promises = __toESM(require("fs/promises"), 1);
 // ../../node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
 init_cjs_shims();
 var import_node_process = __toESM(require("process"), 1);
-var import_node_os = __toESM(require("os"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
 var import_node_fs3 = __toESM(require("fs"), 1);
 
 // ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
@@ -9404,7 +10375,7 @@ var isWsl = () => {
   if (import_node_process.default.platform !== "linux") {
     return false;
   }
-  if (import_node_os.default.release().toLowerCase().includes("microsoft")) {
+  if (import_node_os3.default.release().toLowerCase().includes("microsoft")) {
     if (isInsideContainer()) {
       return false;
     }
@@ -9600,7 +10571,7 @@ async function defaultBrowser2() {
 var execFile5 = (0, import_node_util5.promisify)(import_node_child_process5.default.execFile);
 var __dirname2 = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 var localXdgOpenPath = import_node_path.default.join(__dirname2, "xdg-open");
-var { platform: platform2, arch } = import_node_process6.default;
+var { platform: platform3, arch } = import_node_process6.default;
 async function getWindowsDefaultBrowserFromWsl() {
   const powershellPath = await powerShellPath();
   const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
@@ -9699,7 +10670,7 @@ var baseOpen = async (options) => {
   let command;
   const cliArguments = [];
   const childProcessOptions = {};
-  if (platform2 === "darwin") {
+  if (platform3 === "darwin") {
     command = "open";
     if (options.wait) {
       cliArguments.push("--wait-apps");
@@ -9713,7 +10684,7 @@ var baseOpen = async (options) => {
     if (app) {
       cliArguments.push("-a", app);
     }
-  } else if (platform2 === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+  } else if (platform3 === "win32" || is_wsl_default && !isInsideContainer() && !app) {
     command = await powerShellPath();
     cliArguments.push(
       "-NoProfile",
@@ -9753,7 +10724,7 @@ var baseOpen = async (options) => {
         exeLocalXdgOpen = true;
       } catch {
       }
-      const useSystemXdgOpen = import_node_process6.default.versions.electron ?? (platform2 === "android" || isBundled || !exeLocalXdgOpen);
+      const useSystemXdgOpen = import_node_process6.default.versions.electron ?? (platform3 === "android" || isBundled || !exeLocalXdgOpen);
       command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
     }
     if (appArguments.length > 0) {
@@ -9764,7 +10735,7 @@ var baseOpen = async (options) => {
       childProcessOptions.detached = true;
     }
   }
-  if (platform2 === "darwin" && appArguments.length > 0) {
+  if (platform3 === "darwin" && appArguments.length > 0) {
     cliArguments.push("--args", ...appArguments);
   }
   if (options.target) {
@@ -9772,14 +10743,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = import_node_child_process5.default.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve7(subprocess);
+        resolve8(subprocess);
       });
     });
   }
@@ -9805,12 +10776,12 @@ function detectArchBinary(binary) {
   }
   return archBinary;
 }
-function detectPlatformBinary({ [platform2]: platformBinary }, { wsl }) {
+function detectPlatformBinary({ [platform3]: platformBinary }, { wsl }) {
   if (wsl && is_wsl_default) {
     return detectArchBinary(wsl);
   }
   if (!platformBinary) {
-    throw new Error(`${platform2} is not supported`);
+    throw new Error(`${platform3} is not supported`);
   }
   return detectArchBinary(platformBinary);
 }
@@ -9855,9 +10826,9 @@ var open_default = open;
 
 // src/api/client.ts
 init_cjs_shims();
-var fs11 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var import_node_fs4 = require("fs");
-var path7 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 var import_mime = __toESM(require("mime"));
 
 // src/utils/errors.ts
@@ -9886,10 +10857,10 @@ var NetworkError = class extends CLIError {
 // src/api/client.ts
 init_logger();
 var DEFAULT_TIMEOUT = 3e4;
-async function apiRequest(path22, options = {}) {
+async function apiRequest(path25, options = {}) {
   const { method = "GET", body, query, timeout = DEFAULT_TIMEOUT, requireAuth = true } = options;
   const endpoint = getApiEndpoint();
-  let url = `${endpoint}${path22}`;
+  let url = `${endpoint}${path25}`;
   if (query && Object.keys(query).length > 0) {
     const params = new URLSearchParams(query);
     url = `${url}?${params.toString()}`;
@@ -9927,7 +10898,7 @@ async function apiRequest(path22, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Request: ${method} ${path22}`);
+    logger.debug(`API Request: ${method} ${path25}`);
     const response = await fetch(url, {
       method,
       headers,
@@ -10042,10 +11013,10 @@ function mapAPIError(status, response) {
   }
   return new CLIError(errCode, errMsg);
 }
-async function apiRequestStream(path22, options = {}) {
+async function apiRequestStream(path25, options = {}) {
   const { timeout = 3e5 } = options;
   const endpoint = getApiEndpoint();
-  const url = `${endpoint}${path22}`;
+  const url = `${endpoint}${path25}`;
   const headers = {
     "User-Agent": "refly-cli/0.1.0"
   };
@@ -10076,7 +11047,7 @@ async function apiRequestStream(path22, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Stream Request: GET ${path22}`);
+    logger.debug(`API Stream Request: GET ${path25}`);
     const response = await fetch(url, {
       method: "GET",
       headers,
@@ -10171,7 +11142,7 @@ async function uploadToPresignedUrl(presignedUrl, filePath, contentType, retryCo
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
-      const fileBuffer = await fs11.promises.readFile(filePath);
+      const fileBuffer = await fs15.promises.readFile(filePath);
       const response = await fetch(presignedUrl, {
         method: "PUT",
         headers: {
@@ -10229,7 +11200,7 @@ async function apiGetWorkflow(workflowId) {
   return apiRequest(`/v1/cli/workflow/${workflowId}`);
 }
 async function apiUploadDriveFile(filePath, canvasId, options) {
-  const filename = path7.basename(filePath);
+  const filename = path10.basename(filePath);
   const mimeType = getMimeType(filePath);
   const fileStats = (0, import_node_fs4.statSync)(filePath);
   logger.debug(`Starting presigned upload: ${filename} (${fileStats.size} bytes)`);
@@ -10492,7 +11463,7 @@ async function getUserInfoFromToken(accessToken) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 
 // src/commands/init.ts
@@ -10552,7 +11523,38 @@ var initCommand = new Command("init").description("Initialize Refly CLI, install
         printError2("Slash commands installation failed");
       }
       println("");
-    } else if (!pretty) {
+    }
+    const installedAgents = await detectInstalledAgents();
+    const deployableAgents = installedAgents.filter((a) => a.format !== "unknown");
+    if (pretty && tty && deployableAgents.length > 0) {
+      println(`Found ${deployableAgents.length} installed agent(s):`);
+      for (const agent of deployableAgents) {
+        const dir = agent.globalSkillsDir || agent.skillsDir || "N/A";
+        println(`  \u2713 ${agent.displayName.padEnd(16)} ${dir}`);
+      }
+      println("");
+    }
+    const platformResults = [];
+    if (deployableAgents.length > 0) {
+      const deployResult = await deploySkillToAllPlatforms("refly", { force: true });
+      for (const [agentName, result] of deployResult.results) {
+        platformResults.push({
+          agent: agentName,
+          success: result.success,
+          path: result.deployedPath || void 0
+        });
+      }
+      if (pretty && tty) {
+        const successCount = platformResults.filter((r) => r.success).length;
+        if (successCount === deployableAgents.length) {
+          printSuccess(`Synced to ${successCount} agent(s)`);
+        } else {
+          printDim(`Synced to ${successCount}/${deployableAgents.length} agent(s)`);
+        }
+        println("");
+      }
+    }
+    if (!pretty) {
       print("init", {
         message: "Refly CLI initialized successfully",
         configDir: getReflyDir(),
@@ -10562,7 +11564,11 @@ var initCommand = new Command("init").description("Initialize Refly CLI, install
         symlinkPath: installResult.symlinkPath,
         commandsInstalled: installResult.commandsInstalled,
         commandsPath: installResult.commandsPath,
-        version: installResult.version
+        version: installResult.version,
+        platforms: {
+          detected: installedAgents.map((a) => a.name),
+          deployed: platformResults
+        }
       });
     }
     if (!skipLogin && !isAuthenticated2) {
@@ -10750,7 +11756,7 @@ var import_node_child_process6 = require("child_process");
 var import_node_fs5 = __toESM(require("fs"));
 init_logger();
 init_paths();
-var CLI_VERSION = "0.1.23";
+var CLI_VERSION = "0.1.25";
 var NPM_TAG = "latest";
 function compareSemver(a, b) {
   const parseVersion = (v) => {
@@ -11006,16 +12012,16 @@ configCommand.action(() => {
   };
   ok("config", safeConfig);
 });
-function getNestedValue(obj, path22) {
-  return path22.split(".").reduce((current, key) => {
+function getNestedValue(obj, path25) {
+  return path25.split(".").reduce((current, key) => {
     if (current && typeof current === "object" && key in current) {
       return current[key];
     }
     return void 0;
   }, obj);
 }
-function setNestedValue(obj, path22, value) {
-  const keys = path22.split(".");
+function setNestedValue(obj, path25, value) {
+  const keys = path25.split(".");
   const lastKey = keys.pop();
   let current = obj;
   for (const key of keys) {
@@ -11256,14 +12262,14 @@ var workflowDeleteCommand = new Command("delete").description("Delete a workflow
 init_cjs_shims();
 var readline2 = __toESM(require("readline/promises"));
 var import_node_process8 = require("process");
-var path9 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 
 // src/utils/prompt.ts
 init_cjs_shims();
 var readline = __toESM(require("readline/promises"));
 var import_node_process7 = require("process");
-var fs13 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 function isInteractive() {
   return process.stdin?.isTTY ?? false;
 }
@@ -11287,12 +12293,12 @@ async function promptForFilePath(variableName, resourceTypes, isRequired) {
         const homeDir = process.env.HOME || process.env.USERPROFILE || "";
         resolvedPath = resolvedPath.replace("~", homeDir);
       }
-      resolvedPath = path8.resolve(resolvedPath);
-      if (!fs13.existsSync(resolvedPath)) {
+      resolvedPath = path11.resolve(resolvedPath);
+      if (!fs17.existsSync(resolvedPath)) {
         console.log(`    File not found: ${resolvedPath}`);
         continue;
       }
-      const stats = fs13.statSync(resolvedPath);
+      const stats = fs17.statSync(resolvedPath);
       if (!stats.isFile()) {
         console.log(`    Not a file: ${resolvedPath}`);
         continue;
@@ -11490,12 +12496,12 @@ async function pollToolsStatus(workflowId, maxWaitTime = 15 * 60 * 1e3, pollInte
         );
         previousRemainingCount = remainingCount;
       }
-      await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+      await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
     } catch (error) {
       console.log(`
 \u26A0\uFE0F  Failed to check authorization status: ${error.message}`);
       console.log("Continuing to wait...");
-      await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+      await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
     }
   }
   console.log("\n\u23F0 Timeout waiting for tool authorization.");
@@ -11606,7 +12612,7 @@ ${details}`;
     if (!filePath) {
       continue;
     }
-    const filename = path9.basename(filePath);
+    const filename = path12.basename(filePath);
     process.stdout.write(`  Uploading ${filename}...`);
     try {
       const uploadResult = await apiUploadDriveFile(filePath, workflowId);
@@ -11988,7 +12994,7 @@ var workflowStatusCommand = new Command("status").description("Get detailed work
       });
       prevStatus = status;
       while (status.status === "init" || status.status === "executing") {
-        await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
+        await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
         status = await fetchStatus();
         if (options.full || hasStatusChanged(prevStatus, status)) {
           if (options.full) {
@@ -12116,7 +13122,75 @@ var workflowDetailCommand = new Command("detail").description("Get detailed work
 
 // src/commands/workflow/toolcalls.ts
 init_cjs_shims();
-var workflowToolcallsCommand = new Command("toolcalls").description("Get all tool calls for workflow execution").argument("<id>", "Workflow ID (c-xxx) or Run ID (we-xxx)").option("--node-id <nodeId>", "Filter by node ID").option("--toolset-id <toolsetId>", "Filter by toolset ID").option("--tool-name <toolName>", "Filter by tool name").option("--status <status>", "Filter by status (executing, completed, failed)").option("--limit <limit>", "Maximum number of results (default: 100)", "100").option("--offset <offset>", "Pagination offset (default: 0)", "0").option("--raw", "Disable output sanitization (show full tool outputs)").action(async (id, options) => {
+function extractNodeOutputs(toolCalls) {
+  const outputs = [];
+  for (const call of toolCalls) {
+    if (!call.output || call.status !== "completed") continue;
+    const output3 = call.output;
+    const filesMap = /* @__PURE__ */ new Map();
+    let content;
+    if (Array.isArray(output3.files)) {
+      for (const f of output3.files) {
+        const file = f;
+        if (file.fileId && !filesMap.has(String(file.fileId))) {
+          filesMap.set(String(file.fileId), {
+            fileId: String(file.fileId),
+            name: String(file.name || ""),
+            type: String(file.type || ""),
+            category: file.category,
+            size: file.size,
+            url: file.url,
+            source: file.source,
+            createdAt: file.createdAt
+          });
+        }
+      }
+    }
+    if (output3.data && typeof output3.data === "object") {
+      const data = output3.data;
+      if (data.fileId && !filesMap.has(String(data.fileId))) {
+        filesMap.set(String(data.fileId), {
+          fileId: String(data.fileId),
+          name: String(data.name || ""),
+          type: String(data.type || ""),
+          category: data.category,
+          size: data.size,
+          url: data.url,
+          source: data.source,
+          createdAt: data.createdAt
+        });
+      }
+    }
+    if (output3.content) {
+      content = String(output3.content).slice(0, 500);
+    } else if (output3.data && typeof output3.data === "object") {
+      const data = output3.data;
+      if (data.candidates && Array.isArray(data.candidates)) {
+        const parts = data.candidates[0]?.content;
+        if (parts?.parts && Array.isArray(parts.parts)) {
+          const textPart = parts.parts.find(
+            (p) => typeof p.text === "string" && !p.thought
+          );
+          if (textPart) {
+            content = String(textPart.text).slice(0, 500);
+          }
+        }
+      }
+    }
+    const files = Array.from(filesMap.values());
+    if (files.length > 0 || content) {
+      outputs.push({
+        nodeId: call.nodeId || "",
+        nodeTitle: call.nodeTitle || call.toolName,
+        toolName: call.toolName,
+        content,
+        files
+      });
+    }
+  }
+  return outputs;
+}
+var workflowToolcallsCommand = new Command("toolcalls").description("Get all tool calls for workflow execution").argument("<id>", "Workflow ID (c-xxx) or Run ID (we-xxx)").option("--node-id <nodeId>", "Filter by node ID").option("--toolset-id <toolsetId>", "Filter by toolset ID").option("--tool-name <toolName>", "Filter by tool name").option("--status <status>", "Filter by status (executing, completed, failed)").option("--limit <limit>", "Maximum number of results (default: 100)", "100").option("--offset <offset>", "Pagination offset (default: 0)", "0").option("--raw", "Disable output sanitization (show full tool outputs)").option("--files", "Show only files and content from each node (simplified output)").option("--latest", "With --files, only show files from the most recent toolcall").action(async (id, options) => {
   try {
     const params = new URLSearchParams();
     if (options.nodeId) {
@@ -12137,12 +13211,26 @@ var workflowToolcallsCommand = new Command("toolcalls").description("Get all too
     if (options.offset) {
       params.set("offset", options.offset);
     }
-    if (options.raw) {
+    if (options.raw || options.files) {
       params.set("sanitizeForDisplay", "false");
     }
     const idType = detectIdType2(id);
     const url = buildWorkflowApiUrl(id, "toolcalls", params);
     const result = await apiRequest(url);
+    if (options.files) {
+      let nodeOutputs = extractNodeOutputs(result.toolCalls);
+      if (options.latest && nodeOutputs.length > 0) {
+        const lastWithFiles = nodeOutputs.filter((n) => n.files.length > 0).pop();
+        nodeOutputs = lastWithFiles ? [lastWithFiles] : [];
+      }
+      const allFiles = nodeOutputs.flatMap((n) => n.files);
+      ok("workflow.files", {
+        runId: result.runId,
+        workflowId: result.workflowId,
+        files: allFiles,
+        nodes: nodeOutputs
+      });
+    }
     ok("workflow.toolcalls", {
       runId: result.runId,
       workflowId: result.workflowId,
@@ -13305,16 +14393,16 @@ var fileGetCommand = new Command("get").description("Get file details").argument
 
 // src/commands/file/download.ts
 init_cjs_shims();
-var fs14 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var fileDownloadCommand = new Command("download").description("Download file to local filesystem").argument("<fileId>", "File ID").option("-o, --output <path>", "Output file path (defaults to original filename)").action(async (fileId, options) => {
   try {
     const { data, filename, contentType, size } = await apiRequestStream(
       `/v1/cli/drive/files/${fileId}/download`
     );
     const outputPath = options.output || filename || `${fileId}`;
-    const resolvedPath = path10.resolve(outputPath);
-    fs14.writeFileSync(resolvedPath, data);
+    const resolvedPath = path13.resolve(outputPath);
+    fs18.writeFileSync(resolvedPath, data);
     ok("file.download", {
       fileId,
       path: resolvedPath,
@@ -13339,8 +14427,8 @@ var fileDownloadCommand = new Command("download").description("Download file to
 
 // src/commands/file/upload.ts
 init_cjs_shims();
-var fs15 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var MAX_FILES = 10;
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes}B`;
@@ -13350,8 +14438,8 @@ function formatSize(bytes) {
 var fileUploadCommand = new Command("upload").description("Upload file(s) to a canvas").argument("<path>", "File or directory path").requiredOption("--canvas-id <id>", "Canvas ID (required)").option("--filter <extensions>", "Filter by extensions (e.g., pdf,docx,png)").action(async (inputPath, options) => {
   const formatter = getFormatter();
   try {
-    const resolvedPath = path11.resolve(inputPath);
-    if (!fs15.existsSync(resolvedPath)) {
+    const resolvedPath = path14.resolve(inputPath);
+    if (!fs19.existsSync(resolvedPath)) {
       fail(ErrorCodes.NOT_FOUND, `Path not found: ${inputPath}`, {
         hint: "Check if the file or directory exists"
       });
@@ -13369,8 +14457,8 @@ var fileUploadCommand = new Command("upload").description("Upload file(s) to a c
     const errors = [];
     for (let i = 0; i < files.length; i++) {
       const filePath = files[i];
-      const filename = path11.basename(filePath);
-      const fileStats = fs15.statSync(filePath);
+      const filename = path14.basename(filePath);
+      const fileStats = fs19.statSync(filePath);
       const sizeStr = formatSize(fileStats.size);
       let currentStage = "presign";
       const updateProgress = () => {
@@ -13451,11 +14539,11 @@ var fileUploadCommand = new Command("upload").description("Upload file(s) to a c
   }
 });
 function resolveFilesToUpload(inputPath, filter) {
-  const stats = fs15.statSync(inputPath);
+  const stats = fs19.statSync(inputPath);
   if (stats.isFile()) {
     if (filter) {
       const filterExts = filter.split(",").map((e) => e.trim().toLowerCase());
-      const ext = path11.extname(inputPath).slice(1).toLowerCase();
+      const ext = path14.extname(inputPath).slice(1).toLowerCase();
       if (!filterExts.includes(ext)) {
         return [];
       }
@@ -13463,21 +14551,21 @@ function resolveFilesToUpload(inputPath, filter) {
     return [inputPath];
   }
   if (stats.isDirectory()) {
-    const entries = fs15.readdirSync(inputPath);
+    const entries = fs19.readdirSync(inputPath);
     const filterExts = filter?.split(",").map((e) => e.trim().toLowerCase());
-    const files = entries.map((e) => path11.join(inputPath, e)).filter((p) => {
+    const files = entries.map((e) => path14.join(inputPath, e)).filter((p) => {
       try {
-        return fs15.statSync(p).isFile();
+        return fs19.statSync(p).isFile();
       } catch {
         return false;
       }
     }).filter((p) => {
       if (!filterExts) return true;
-      const ext = path11.extname(p).slice(1).toLowerCase();
+      const ext = path14.extname(p).slice(1).toLowerCase();
       return filterExts.includes(ext);
     }).sort((a, b) => {
       try {
-        return fs15.statSync(a).size - fs15.statSync(b).size;
+        return fs19.statSync(a).size - fs19.statSync(b).size;
       } catch {
         return 0;
       }
@@ -13581,7 +14669,7 @@ var skillGetCommand = new Command("get").description("Get skill package details"
 
 // src/commands/skill/create.ts
 init_cjs_shims();
-var fs16 = __toESM(require("fs"));
+var fs20 = __toESM(require("fs"));
 init_symlink();
 init_paths();
 init_logger();
@@ -13633,7 +14721,7 @@ var skillCreateCommand = new Command("create").description("Create a new skill p
         const localName = options.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
         const skillDir = getReflyDomainSkillDir(localName);
         const symlinkStatus = isSkillSymlinkValid(localName);
-        if (fs16.existsSync(skillDir) || symlinkStatus.exists) {
+        if (fs20.existsSync(skillDir) || symlinkStatus.exists) {
           logger.debug(`Local skill '${localName}' already exists, skipping sync`);
         } else {
           const skillMdContent = generateReflySkillMd({
@@ -13695,8 +14783,8 @@ var skillCreateCommand = new Command("create").description("Create a new skill p
 
 // src/commands/skill/update.ts
 init_cjs_shims();
-var fs17 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 init_paths();
 init_symlink();
 var MIN_DESCRIPTION_WORDS = 20;
@@ -13726,8 +14814,8 @@ var skillUpdateCommand = new Command("update").description("Update skill install
   try {
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
-    const skillMdPath = path12.join(skillDir, "SKILL.md");
-    if (!fs17.existsSync(skillMdPath)) {
+    const skillMdPath = path15.join(skillDir, "SKILL.md");
+    if (!fs21.existsSync(skillMdPath)) {
       const skillsDir = getReflySkillsDir();
       fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
         hint: `Make sure the skill '${name}' exists in ${skillsDir}/
@@ -13736,7 +14824,7 @@ To see installed skills: refly skill list`
       });
       return;
     }
-    const skillContent = fs17.readFileSync(skillMdPath, "utf-8");
+    const skillContent = fs21.readFileSync(skillMdPath, "utf-8");
     let meta;
     try {
       const parsed = parseReflySkillMd(skillContent);
@@ -13819,8 +14907,8 @@ To see installed skills: refly skill list`
 
 // src/commands/skill/publish.ts
 init_cjs_shims();
-var fs18 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 init_symlink();
 init_paths();
 var skillPublishCommand = new Command("publish").description("Publish a skill package using local SKILL.md").requiredOption("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
@@ -13828,8 +14916,8 @@ var skillPublishCommand = new Command("publish").description("Publish a skill pa
     const skillsDir = getReflySkillsDir();
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
-    const skillMdPath = path13.join(skillDir, "SKILL.md");
-    if (!fs18.existsSync(skillMdPath)) {
+    const skillMdPath = path16.join(skillDir, "SKILL.md");
+    if (!fs22.existsSync(skillMdPath)) {
       fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
         hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -13838,7 +14926,7 @@ To create a new skill: refly skill create --name "${name}" --workflow-query "...
       });
       return;
     }
-    const skillContent = fs18.readFileSync(skillMdPath, "utf-8");
+    const skillContent = fs22.readFileSync(skillMdPath, "utf-8");
     let parsedSkill;
     try {
       parsedSkill = parseReflySkillMd(skillContent);
@@ -13900,8 +14988,8 @@ To find available skills: refly skill list`
 
 // src/commands/skill/unpublish.ts
 init_cjs_shims();
-var fs19 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 init_symlink();
 init_paths();
 var skillUnpublishCommand = new Command("unpublish").description("Unpublish a skill package to make it private").option("--id <skillId>", "Skill ID (skp-xxx)").option("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
@@ -13936,8 +15024,8 @@ To find your skill name:
         return;
       }
       const skillDir = getReflyDomainSkillDir(name);
-      const skillMdPath = path14.join(skillDir, "SKILL.md");
-      if (!fs19.existsSync(skillMdPath)) {
+      const skillMdPath = path17.join(skillDir, "SKILL.md");
+      if (!fs23.existsSync(skillMdPath)) {
         fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
           hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -13945,7 +15033,7 @@ To see installed skills: refly skill list`
         });
         return;
       }
-      const skillContent = fs19.readFileSync(skillMdPath, "utf-8");
+      const skillContent = fs23.readFileSync(skillMdPath, "utf-8");
       try {
         const { meta } = parseReflySkillMd(skillContent);
         skillId = options.id || meta.skillId;
@@ -13989,8 +15077,8 @@ To see installed skills: refly skill list`
 
 // src/commands/skill/run.ts
 init_cjs_shims();
-var fs20 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 init_symlink();
 init_paths();
 var skillRunCommand = new Command("run").description("Run an installed skill").option("--id <installationId>", "Installation ID (skpi-xxx)").option("--name <name>", "Local skill name (directory in ~/.refly/skills/)").option("--input <json>", "Input JSON for the skill").option("--workflow <skillWorkflowId>", "Run specific workflow only").option("--async", "Run asynchronously").option("--no-prompt", "Disable interactive prompts (fail if required variables are missing)").action(async (options) => {
@@ -14015,8 +15103,8 @@ To find your skill name:
     if (options.name) {
       name = options.name;
       const skillDir = getReflyDomainSkillDir(options.name);
-      const skillMdPath = path15.join(skillDir, "SKILL.md");
-      if (!fs20.existsSync(skillMdPath)) {
+      const skillMdPath = path18.join(skillDir, "SKILL.md");
+      if (!fs24.existsSync(skillMdPath)) {
         fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
           hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -14025,7 +15113,7 @@ To install a skill: refly skill install <skillId>`
         });
         return;
       }
-      const skillContent = fs20.readFileSync(skillMdPath, "utf-8");
+      const skillContent = fs24.readFileSync(skillMdPath, "utf-8");
       try {
         const { meta } = parseReflySkillMd(skillContent);
         skillId = meta.skillId;
@@ -14143,24 +15231,24 @@ To install: refly skill install ${meta.skillId}`
 
 // src/commands/skill/stop.ts
 init_cjs_shims();
-var fs21 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 init_symlink();
 init_paths();
 function getLocalSkillNames() {
   const skillsDir = getReflySkillsDir();
-  if (!fs21.existsSync(skillsDir)) {
+  if (!fs25.existsSync(skillsDir)) {
     return [];
   }
-  return fs21.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  return fs25.readdirSync(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
 }
 var skillStopCommand = new Command("stop").description("Stop running skill executions").requiredOption("--name <name>", "Local skill name (directory in ~/.refly/skills/)").action(async (options) => {
   try {
     const skillsDir = getReflySkillsDir();
     const name = options.name;
     const skillDir = getReflyDomainSkillDir(name);
-    const skillMdPath = path16.join(skillDir, "SKILL.md");
-    if (!fs21.existsSync(skillMdPath)) {
+    const skillMdPath = path19.join(skillDir, "SKILL.md");
+    if (!fs25.existsSync(skillMdPath)) {
       const availableSkills = getLocalSkillNames();
       const skillList = availableSkills.length > 0 ? availableSkills.join(", ") : "(no skills installed)";
       fail(ErrorCodes.NOT_FOUND, `Skill "${name}" not found`, {
@@ -14169,7 +15257,7 @@ var skillStopCommand = new Command("stop").description("Stop running skill execu
 Skills directory: ${skillsDir}`
       });
     }
-    const skillContent = fs21.readFileSync(skillMdPath, "utf-8");
+    const skillContent = fs25.readFileSync(skillMdPath, "utf-8");
     let installationId;
     try {
       const { meta } = parseReflySkillMd(skillContent);
@@ -14297,7 +15385,7 @@ var skillInstallCommand = new Command("install").description("Install a skill pa
       }
     );
     let localPath;
-    let symlinkPath;
+    const platformResults = [];
     const skillName = result.skillPackage?.name;
     const workflowId = result.skillPackage?.workflowId;
     if (skillName && workflowId) {
@@ -14315,15 +15403,23 @@ var skillInstallCommand = new Command("install").description("Install a skill pa
           inputSchema: result.skillPackage?.inputSchema,
           outputSchema: result.skillPackage?.outputSchema
         });
-        const symlinkResult = createReflySkillWithSymlink(skillName, skillMdContent, {
+        const deployResult = await createMultiPlatformSkill(skillName, skillMdContent, {
           force: options.force
         });
-        if (symlinkResult.success) {
-          localPath = symlinkResult.reflyPath;
-          symlinkPath = symlinkResult.claudePath;
-          logger.info(`Created local skill: ${localPath}`);
+        localPath = deployResult.sourcePath;
+        for (const [agentName, agentResult] of deployResult.results) {
+          platformResults.push({
+            agent: agentName,
+            success: agentResult.success,
+            path: agentResult.deployedPath || void 0
+          });
+        }
+        if (deployResult.successCount > 0) {
+          logger.info(
+            `Created local skill: ${localPath}, deployed to ${deployResult.successCount} platform(s)`
+          );
         } else {
-          logger.warn(`Failed to create local skill: ${symlinkResult.error}`);
+          logger.warn("Failed to deploy skill to any platform");
         }
       } catch (err) {
         logger.warn(`Failed to create local skill: ${err.message}`);
@@ -14338,7 +15434,7 @@ var skillInstallCommand = new Command("install").description("Install a skill pa
       config: result.userConfig,
       installedAt: result.createdAt,
       localPath,
-      symlinkPath
+      platforms: platformResults.length > 0 ? platformResults : void 0
     });
   } catch (error) {
     if (error instanceof CLIError) {
@@ -14358,8 +15454,8 @@ var skillInstallCommand = new Command("install").description("Install a skill pa
 
 // src/commands/skill/uninstall.ts
 init_cjs_shims();
-var fs22 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 init_symlink();
 init_paths();
 init_logger();
@@ -14396,8 +15492,8 @@ To find your skill name:
         return;
       }
       const skillDir = getReflyDomainSkillDir(name);
-      const skillMdPath = path17.join(skillDir, "SKILL.md");
-      if (!fs22.existsSync(skillMdPath)) {
+      const skillMdPath = path20.join(skillDir, "SKILL.md");
+      if (!fs26.existsSync(skillMdPath)) {
         fail(ErrorCodes.NOT_FOUND, `SKILL.md not found at ${skillMdPath}`, {
           hint: `Make sure the skill '${name}' exists in ${skillsDir}/
 
@@ -14405,7 +15501,7 @@ To see installed skills: refly skill list`
         });
         return;
       }
-      const skillContent = fs22.readFileSync(skillMdPath, "utf-8");
+      const skillContent = fs26.readFileSync(skillMdPath, "utf-8");
       try {
         const { meta } = parseReflySkillMd(skillContent);
         skillId = meta.skillId;
@@ -14436,14 +15532,21 @@ To see installed skills: refly skill list`
         }
       }
     }
-    let symlinkRemoved = false;
     let directoryRemoved = false;
+    const platformResults = [];
     if (name && !options.keepLocal) {
       try {
-        const cleanup = deleteDomainSkillWithSymlink(name);
-        symlinkRemoved = cleanup.symlinkRemoved;
+        const cleanup = await removeMultiPlatformSkill(name);
         directoryRemoved = cleanup.directoryRemoved;
-        logger.info(`Cleaned up local skill: ${name}`);
+        for (const [agentName, result] of cleanup.platformResults.results) {
+          platformResults.push({
+            agent: agentName,
+            success: result.success
+          });
+        }
+        logger.info(
+          `Cleaned up local skill: ${name}, removed from ${cleanup.platformResults.successCount} platform(s)`
+        );
       } catch (err) {
         logger.warn(`Failed to clean up local skill: ${err.message}`);
       }
@@ -14454,8 +15557,8 @@ To see installed skills: refly skill list`
       installationId,
       uninstalled: true,
       localCleanup: {
-        symlinkRemoved,
-        directoryRemoved
+        directoryRemoved,
+        platforms: platformResults.length > 0 ? platformResults : void 0
       }
     });
   } catch (error) {
@@ -14521,8 +15624,8 @@ init_cjs_shims();
 
 // src/skill/loader.ts
 init_cjs_shims();
-var fs23 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
 var import_gray_matter = __toESM(require("gray-matter"));
 init_logger();
 
@@ -14702,23 +15805,23 @@ function extractSkillMetadata(content) {
 
 // src/commands/skill/validate.ts
 init_paths();
-var fs24 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var skillValidateCommand = new Command("validate").description("Validate local skill files").argument("[skillPath]", "Path to skill file or directory (defaults to ~/.refly/skills)").option("--fix", "Attempt to fix common issues").action(async (skillPath, _options) => {
   try {
     const results = [];
     let targetPath;
     if (skillPath) {
-      targetPath = path19.resolve(skillPath);
+      targetPath = path22.resolve(skillPath);
     } else {
       await ensureSkillsDir();
       targetPath = getSkillsDir();
     }
-    if (!fs24.existsSync(targetPath)) {
+    if (!fs28.existsSync(targetPath)) {
       fail(ErrorCodes.NOT_FOUND, `Path not found: ${targetPath}`);
       return;
     }
-    const stats = fs24.statSync(targetPath);
+    const stats = fs28.statSync(targetPath);
     if (stats.isFile()) {
       const result = validateSkillFile(targetPath);
       results.push(result);
@@ -14751,7 +15854,7 @@ var skillValidateCommand = new Command("validate").description("Validate local s
 });
 function validateSkillFile(filePath) {
   try {
-    const content = fs24.readFileSync(filePath, "utf-8");
+    const content = fs28.readFileSync(filePath, "utf-8");
     const { frontmatter, issues } = extractSkillMetadata(content);
     const errors = issues.map((i) => `${i.path}: ${i.message}`);
     const warnings = [];
@@ -14777,9 +15880,9 @@ function validateSkillFile(filePath) {
   }
 }
 function findSkillFiles(dir, files = []) {
-  const entries = fs24.readdirSync(dir, { withFileTypes: true });
+  const entries = fs28.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path22.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!entry.name.startsWith(".")) {
         findSkillFiles(fullPath, files);
@@ -14793,12 +15896,73 @@ function findSkillFiles(dir, files = []) {
 
 // src/commands/skill/sync.ts
 init_cjs_shims();
+var fs29 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 init_symlink();
+init_manager();
+init_registry();
 init_paths();
-var fs25 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
-var skillSyncCommand = new Command("sync").description("Validate and repair skill symlinks").option("--dry-run", "Show issues without making changes").option("--fix", "Attempt to repair broken symlinks").option("--prune", "Remove orphan symlinks (symlinks without source directory)").action(async (options) => {
+var skillSyncCommand = new Command("sync").description("Validate and repair skill symlinks across all platforms").option("--dry-run", "Show issues without making changes").option("--fix", "Attempt to repair broken symlinks").option("--prune", "Remove orphan symlinks (symlinks without source directory)").option("--platform <platforms...>", "Sync to specific platforms only (comma-separated)").option("--all-platforms", "Sync to all installed platforms (not just Claude Code)").action(async (options) => {
   try {
+    let targetAgents;
+    if (options.platform) {
+      const platformList = options.platform.flatMap((p) => p.split(","));
+      targetAgents = [];
+      for (const platform4 of platformList) {
+        const trimmed = platform4.trim();
+        if (!isValidAgentType(trimmed)) {
+          return fail(ErrorCodes.INVALID_INPUT, `Unknown platform: ${trimmed}`, {
+            hint: `Valid platforms: ${Object.keys(agents).join(", ")}`
+          });
+        }
+        targetAgents.push(trimmed);
+      }
+    }
+    if (options.allPlatforms) {
+      const installedAgents = await detectInstalledAgents();
+      const deployableAgents = installedAgents.filter((a) => a.format !== "unknown");
+      const skillsDir2 = getReflySkillsDir();
+      const baseSkillDir = getReflyBaseSkillDir();
+      const skillsToSync = [];
+      if (fs29.existsSync(baseSkillDir)) {
+        skillsToSync.push("refly");
+      }
+      if (fs29.existsSync(skillsDir2)) {
+        const entries = fs29.readdirSync(skillsDir2, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name !== "base") {
+            skillsToSync.push(entry.name);
+          }
+        }
+      }
+      const platformResults = [];
+      for (const skillName of skillsToSync) {
+        const { needsSync, synced } = await syncSkillToAllPlatforms(skillName, {
+          agents: targetAgents,
+          dryRun: options.dryRun
+        });
+        platformResults.push({
+          skillName,
+          needsSync: Array.from(needsSync.entries()).map(([agent, status]) => ({
+            agent,
+            deployed: status.deployed,
+            valid: status.valid
+          })),
+          synced: Array.from(synced.entries()).map(([agent, result]) => ({
+            agent,
+            success: result.success,
+            path: result.deployedPath || void 0
+          }))
+        });
+      }
+      return ok("skill.sync", {
+        dryRun: Boolean(options.dryRun),
+        allPlatforms: true,
+        installedAgents: deployableAgents.map((a) => a.name),
+        skillsCount: skillsToSync.length,
+        results: platformResults
+      });
+    }
     const symlinks = listSkillSymlinks();
     const warnings = [];
     const errors = [];
@@ -14823,14 +15987,14 @@ var skillSyncCommand = new Command("sync").description("Validate and repair skil
       }
     }
     const skillsDir = getReflySkillsDir();
-    if (fs25.existsSync(skillsDir)) {
-      const entries = fs25.readdirSync(skillsDir, { withFileTypes: true });
+    if (fs29.existsSync(skillsDir)) {
+      const entries = fs29.readdirSync(skillsDir, { withFileTypes: true });
       const symlinkNames = new Set(symlinks.map((s) => s.name));
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "base") {
           if (!symlinkNames.has(entry.name)) {
             orphans += 1;
-            warnings.push(`Orphan directory (no symlink): ${path20.join(skillsDir, entry.name)}`);
+            warnings.push(`Orphan directory (no symlink): ${path23.join(skillsDir, entry.name)}`);
             if (options.prune && !options.dryRun) {
               const result = createSkillSymlink(entry.name);
               if (result.success) {
@@ -14877,11 +16041,178 @@ var skillSyncCommand = new Command("sync").description("Validate and repair skil
 // src/commands/skill/index.ts
 var skillCommand = new Command("skill").description("Manage skill packages and local skills").addCommand(skillListCommand).addCommand(skillGetCommand).addCommand(skillCreateCommand).addCommand(skillUpdateCommand).addCommand(skillPublishCommand).addCommand(skillUnpublishCommand).addCommand(skillSearchCommand).addCommand(skillInstallCommand).addCommand(skillUninstallCommand).addCommand(skillInstallationsCommand).addCommand(skillRunCommand).addCommand(skillStopCommand).addCommand(skillValidateCommand).addCommand(skillSyncCommand);
 
+// src/commands/platform/index.ts
+init_cjs_shims();
+
+// src/commands/platform/sync.ts
+init_cjs_shims();
+var fs30 = __toESM(require("fs"));
+init_manager();
+init_registry();
+init_paths();
+var platformSyncCommand = new Command("sync").description("Detect installed agents and sync skills to all platforms").option("--agent <agents...>", "Specific agents to sync to (comma-separated)").option("--dry-run", "Show what would be done without making changes").option("--yes", "Skip confirmation prompts").action(async (options) => {
+  try {
+    const pretty = isPrettyOutput();
+    const tty = isTTY();
+    let targetAgents;
+    if (options.agent) {
+      const agentList = options.agent.flatMap((a) => a.split(","));
+      const validatedAgents = [];
+      for (const agent of agentList) {
+        const trimmed = agent.trim();
+        if (!isValidAgentType(trimmed)) {
+          return fail(ErrorCodes.INVALID_INPUT, `Unknown agent: ${trimmed}`, {
+            hint: `Valid agents: ${Object.keys(agents).join(", ")}`
+          });
+        }
+        validatedAgents.push(trimmed);
+      }
+      targetAgents = validatedAgents;
+    }
+    if (pretty && tty) {
+      println("Scanning for installed agents...");
+      println("");
+    }
+    const installedAgents = targetAgents ? targetAgents.map((name) => agents[name]) : await detectInstalledAgents();
+    const deployableAgents = installedAgents.filter((a) => a.format !== "unknown");
+    if (deployableAgents.length === 0) {
+      if (pretty && tty) {
+        printError2("No supported agents found");
+        printDim("Install an AI coding assistant and try again.");
+      } else {
+        ok("platform.sync", {
+          message: "No supported agents found",
+          installedAgents: [],
+          skillsSynced: 0
+        });
+      }
+      return;
+    }
+    if (pretty && tty) {
+      println(`Found ${deployableAgents.length} installed agent(s):`);
+      for (const agent of deployableAgents) {
+        const dir = agent.globalSkillsDir || agent.skillsDir || "N/A";
+        println(`  \u2713 ${agent.displayName.padEnd(16)} ${dir}`);
+      }
+      println("");
+    }
+    const skillsDir = getReflySkillsDir();
+    const baseSkillDir = getReflyBaseSkillDir();
+    const skillsToSync = [];
+    if (fs30.existsSync(baseSkillDir)) {
+      skillsToSync.push("refly");
+    }
+    if (fs30.existsSync(skillsDir)) {
+      const entries = fs30.readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== "base") {
+          skillsToSync.push(entry.name);
+        }
+      }
+    }
+    if (skillsToSync.length === 0) {
+      if (pretty && tty) {
+        printDim("No skills found to sync.");
+        printDim("Run `refly init` to install the base skill.");
+      } else {
+        ok("platform.sync", {
+          message: "No skills found to sync",
+          installedAgents: deployableAgents.map((a) => a.name),
+          skillsSynced: 0
+        });
+      }
+      return;
+    }
+    if (pretty && tty) {
+      println(`Syncing ${skillsToSync.length} skill(s) to all installed agents...`);
+    }
+    if (options.dryRun) {
+      if (pretty && tty) {
+        println("");
+        println("Dry run - no changes made:");
+        for (const skillName of skillsToSync) {
+          const agentNames = deployableAgents.map((a) => a.displayName).join(", ");
+          println(`  ${skillName} -> ${agentNames}`);
+        }
+      } else {
+        ok("platform.sync", {
+          dryRun: true,
+          installedAgents: deployableAgents.map((a) => a.name),
+          skillsToSync
+        });
+      }
+      return;
+    }
+    const results = [];
+    for (const skillName of skillsToSync) {
+      const deployResult = await deploySkillToAllPlatforms(skillName, {
+        force: true,
+        // Force to ensure repair
+        agents: targetAgents
+      });
+      const details = [];
+      for (const [agentName, result] of deployResult.results) {
+        details.push({
+          agent: agentName,
+          success: result.success,
+          path: result.deployedPath || void 0,
+          error: result.error
+        });
+      }
+      results.push({
+        skillName,
+        success: deployResult.successCount,
+        failed: deployResult.failureCount,
+        details
+      });
+      if (pretty && tty) {
+        const statusParts = deployableAgents.map((agent) => {
+          const result = deployResult.results.get(agent.name);
+          return result?.success ? "\u2713" : "\u2717";
+        });
+        println(`  ${skillName.padEnd(20)} ${statusParts.join(" ")}`);
+      }
+    }
+    const totalSuccess = results.reduce((sum, r) => sum + r.success, 0);
+    const totalFailed = results.reduce((sum, r) => sum + r.failed, 0);
+    if (pretty && tty) {
+      println("");
+      printSuccess(
+        `Done! ${deployableAgents.length} agent(s), ${skillsToSync.length} skill(s) synced.`
+      );
+      if (totalFailed > 0) {
+        printError2(`${totalFailed} deployment(s) failed. Check logs for details.`);
+      }
+    } else {
+      ok("platform.sync", {
+        installedAgents: deployableAgents.map((a) => ({
+          name: a.name,
+          displayName: a.displayName,
+          format: a.format,
+          globalSkillsDir: a.globalSkillsDir
+        })),
+        skillsSynced: skillsToSync.length,
+        totalSuccess,
+        totalFailed,
+        results
+      });
+    }
+  } catch (error) {
+    fail(
+      ErrorCodes.INTERNAL_ERROR,
+      error instanceof Error ? error.message : "Failed to sync platforms"
+    );
+  }
+});
+
+// src/commands/platform/index.ts
+var platformCommand = new Command("platform").description("Manage multi-platform skill deployment").addCommand(platformSyncCommand);
+
 // src/bin/refly.ts
 function getVersion() {
   try {
-    const pkgPath = path21.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path24.join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf-8"));
     return pkg.version || "0.1.0";
   } catch {
     return "0.1.0";
@@ -14922,6 +16253,7 @@ program2.addCommand(workflowCommand);
 program2.addCommand(toolCommand);
 program2.addCommand(fileCommand);
 program2.addCommand(skillCommand);
+program2.addCommand(platformCommand);
 program2.exitOverride((err) => {
   if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
     process.exit(0);