rush-ai 0.10.0 → 0.11.0

package/dist/index.js

@@ -1,4 +1,13 @@
 #!/usr/bin/env node
+import {
+  consumeSSEStreamWithReconnect
+} from "./chunk-MG4HY2PD.js";
+import {
+  AtomicJsonConflictError,
+  pathExists,
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-V7P2TZZ4.js";
 import {
   ApiError,
   AuthError,
@@ -7,7 +16,6 @@ import {
   VERSION,
   checkAuthSourceMismatch,
   clearAuthConfig,
-  consumeSSEStreamWithReconnect,
   createClient,
   createProfile,
   deleteProfile,
@@ -29,7 +37,7 @@ import {
   setGlobalConfig,
   setVerbosity,
   verifyCurrentAuthSession
-} from "./chunk-SZO6LEQX.js";
+} from "./chunk-3X5X3ZTX.js";
 
 // src/index.ts
 import chalk7 from "chalk";
@@ -2897,7 +2905,7 @@ var MarketplaceCache = class {
    */
   async remove(name) {
     const target = this.pathFor(name);
-    if (!await pathExists(target)) {
+    if (!await pathExists2(target)) {
       return;
     }
     await rm2(target, { recursive: true, force: true });
@@ -2944,7 +2952,7 @@ var MarketplaceCache = class {
    * v1 暂不单列损坏项；若未来需要，可加 `options.includeCorrupt` 返回 warning。
    */
   async list() {
-    if (!await pathExists(this.cacheBaseDir)) {
+    if (!await pathExists2(this.cacheBaseDir)) {
       return [];
     }
     const entries = await readdir(this.cacheBaseDir, { withFileTypes: true });
@@ -3009,7 +3017,7 @@ var MarketplaceCache = class {
   }
   async readMeta(name) {
     const metaPath = this.metaPathFor(name);
-    if (!await pathExists(metaPath)) {
+    if (!await pathExists2(metaPath)) {
       return null;
     }
     const raw = await readFile3(metaPath, "utf8");
@@ -3052,7 +3060,7 @@ var MarketplaceCache = class {
     await atomicWriteJson(metaPath, payload);
   }
 };
-async function pathExists(p) {
+async function pathExists2(p) {
   try {
     await access3(p, fsConstants3.F_OK);
     return true;
@@ -3268,7 +3276,7 @@ function assertRegistryShape(raw, filePath) {
     );
   }
 }
-async function pathExists2(p) {
+async function pathExists3(p) {
   try {
     await access4(p, fsConstants4.F_OK);
     return true;
@@ -3289,7 +3297,7 @@ async function atomicWrite(filePath, content) {
   }
 }
 async function loadFromPath(filePath) {
-  if (!await pathExists2(filePath)) {
+  if (!await pathExists3(filePath)) {
     return {
       data: { schemaVersion: REGISTRY_SCHEMA_VERSION, plugins: {} },
       mtimeMs: null
@@ -3396,7 +3404,7 @@ var RushRegistryStore = class _RushRegistryStore {
   async saveWithRetry(attempt) {
     this.assertWriteableSchema();
     if (this.loadedMtimeMs === null) {
-      if (await pathExists2(this.filePath)) {
+      if (await pathExists3(this.filePath)) {
         if (attempt === 0) {
           await this.reloadAndMerge();
           return this.saveWithRetry(1);
@@ -3790,7 +3798,7 @@ function truncate3(str, max) {
 function registerMcpCommand(program) {
   const mcp = program.command("mcp").description("MCP server and platform MCP discovery");
   mcp.command("serve").description("Start the MCP stdio server").action(async () => {
-    const { startMcpServer } = await import("./server-KFDYSF4T.js");
+    const { startMcpServer } = await import("./server-GQMH2YN4.js");
     await startMcpServer();
   });
   mcp.command("list").alias("ls").description("List available MCP servers on the platform").option("-c, --category <category>", "Filter by category").option("-t, --tag <tag>", "Filter by tag").option("-s, --search <query>", "Search by name or description").option("--transport <type>", "Filter by transport type (stdio|sse|http)").option(
@@ -3798,7 +3806,6 @@ function registerMcpCommand(program) {
     "Max results per page (default: 50, max: 100)",
     "50"
   ).option("-p, --page <number>", "Page number (default: 1)", "1").action(async (opts) => {
-    requireAuth();
     const format = resolveFormat(program.opts());
     const client = createClient();
     const params = new URLSearchParams();
@@ -3858,7 +3865,6 @@ function registerMcpCommand(program) {
     }
   });
   mcp.command("list-tools <server-id>").description("List tools provided by an MCP server").action(async (serverId) => {
-    requireAuth();
     const format = resolveFormat(program.opts());
     const client = createClient();
     let data;
@@ -3904,113 +3910,102 @@ function registerMcpCommand(program) {
       })
     );
   });
+  mcp.command("install <mcp-id>").description(
+    "Install an MCP server from Rush registry to Claude Desktop / Claude Code"
+  ).option("-y, --yes", "Skip confirmation prompts (use defaults)").option(
+    "--target <targets>",
+    "Comma-separated targets: claude-desktop,claude-code (default: both)"
+  ).option("--allow-unverified", "Allow installing unverified MCP servers").action(async (mcpId, opts) => {
+    const format = resolveFormat(program.opts());
+    const { runMcpInstall, printMcpInstallSummary } = await import("./install-7J3LP75O.js");
+    try {
+      const result = await runMcpInstall({
+        mcpId,
+        yes: opts.yes,
+        targetRaw: opts.target,
+        allowUnverified: opts.allowUnverified
+      });
+      const anyOk = result.targets.some((t) => t.status === "ok");
+      const anyError = result.targets.some((t) => t.status === "error");
+      if (anyError || !anyOk) process.exitCode = 1;
+      if (format === "json") {
+        output.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      printMcpInstallSummary(result);
+    } catch (err) {
+      if (format === "json") {
+        output.log(
+          JSON.stringify(
+            {
+              error: err instanceof Error ? err.message : String(err)
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        output.error(err instanceof Error ? err.message : String(err));
+      }
+      process.exitCode = 1;
+    }
+  });
+  mcp.command("uninstall <mcp-id>").description(
+    "Remove an MCP server from Claude Desktop / Claude Code config"
+  ).option(
+    "--target <targets>",
+    "Comma-separated targets: claude-desktop,claude-code (default: both)"
+  ).action(async (mcpId, opts) => {
+    const format = resolveFormat(program.opts());
+    const { runMcpUninstall, printMcpUninstallSummary } = await import("./install-7J3LP75O.js");
+    try {
+      const result = await runMcpUninstall({
+        mcpId,
+        targetRaw: opts.target
+      });
+      const anyError = result.targets.some((t) => t.error);
+      if (anyError) process.exitCode = 1;
+      if (format === "json") {
+        output.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      printMcpUninstallSummary(result);
+    } catch (err) {
+      if (format === "json") {
+        output.log(
+          JSON.stringify(
+            {
+              error: err instanceof Error ? err.message : String(err)
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        output.error(err instanceof Error ? err.message : String(err));
+      }
+      process.exitCode = 1;
+    }
+  });
 }
 
-// src/installers/claude-code/atomic-json.ts
+// src/installers/claude-code/installer.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { constants as fsConstants5 } from "fs";
 import {
-  access as access5,
+  copyFile,
+  lstat,
   mkdir as mkdir4,
+  readdir as readdir2,
   readFile as readFile5,
+  readlink,
   rename as rename3,
   rm as rm4,
   stat as stat2,
-  writeFile as writeFile4
-} from "fs/promises";
-import { dirname as dirname4 } from "path";
-var AtomicJsonError = class extends Error {
-  constructor(message, filePath) {
-    super(message);
-    this.filePath = filePath;
-    this.name = "AtomicJsonError";
-  }
-};
-var AtomicJsonCorruptError = class extends AtomicJsonError {
-  constructor(filePath, cause) {
-    super(
-      `${filePath} \u89E3\u6790\u5931\u8D25\uFF0C\u62D2\u7EDD\u8BFB\u53D6\u3002\u8BF7\u624B\u5DE5\u4FEE\u590D\u6216\u5907\u4EFD\u540E\u5220\u9664\u3002\u539F\u56E0\uFF1A${String(
-        cause?.message ?? cause
-      )}`,
-      filePath
-    );
-    this.cause = cause;
-    this.name = "AtomicJsonCorruptError";
-  }
-};
-async function readJsonFile(filePath, defaults) {
-  if (!await pathExists3(filePath)) {
-    return { data: defaults(), mtimeMs: null, existed: false };
-  }
-  const stats = await stat2(filePath);
-  const raw = await readFile5(filePath, "utf8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new AtomicJsonCorruptError(filePath, err);
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new AtomicJsonCorruptError(
-      filePath,
-      new Error("\u9876\u5C42\u5FC5\u987B\u662F JSON object\uFF0C\u4E0D\u5141\u8BB8\u6570\u7EC4\u6216\u57FA\u672C\u7C7B\u578B")
-    );
-  }
-  return {
-    data: parsed,
-    mtimeMs: stats.mtimeMs,
-    existed: true
-  };
-}
-async function writeJsonFile(filePath, data, options = {}) {
-  const { indent = 2, trailingNewline = true } = options;
-  await mkdir4(dirname4(filePath), { recursive: true });
-  const payload = JSON.stringify(data, null, indent) + (trailingNewline ? "\n" : "");
-  const tmp = `${filePath}.${randomUUID3()}.tmp`;
-  try {
-    await writeFile4(tmp, payload, { encoding: "utf8", flag: "w" });
-    await rename3(tmp, filePath);
-  } catch (err) {
-    await rm4(tmp, { force: true }).catch(() => {
-    });
-    throw err;
-  }
-}
-var AtomicJsonConflictError = class extends AtomicJsonError {
-  constructor(filePath) {
-    super(
-      `${filePath} \u5728 read-modify-write \u671F\u95F4\u88AB\u5176\u4ED6\u8FDB\u7A0B\u4FEE\u6539\u3002\u8BF7\u91CD\u8BD5\u3002`,
-      filePath
-    );
-    this.name = "AtomicJsonConflictError";
-  }
-};
-async function pathExists3(p) {
-  try {
-    await access5(p, fsConstants5.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/installers/claude-code/installer.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import {
-  copyFile,
-  lstat,
-  mkdir as mkdir5,
-  readdir as readdir2,
-  readFile as readFile6,
-  readlink,
-  rename as rename4,
-  rm as rm5,
-  stat as stat3,
   symlink,
   unlink
 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname5, join as join9, resolve as resolve9 } from "path";
+import { dirname as dirname4, join as join9, resolve as resolve9 } from "path";
 
 // src/installers/claude-code/mcp.ts
 import { execFileSync as execFileSync4 } from "child_process";
@@ -4169,7 +4164,7 @@ var ClaudeCodeInstaller = class {
     return dirExists(this.paths.claudeDir);
   }
   async isInstalled(ref) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return false;
     }
     const { data } = await readJsonFile(
@@ -4180,7 +4175,7 @@ var ClaudeCodeInstaller = class {
     return Array.isArray(entries) && entries.length > 0;
   }
   async list() {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return [];
     }
     const { data } = await readJsonFile(
@@ -4251,13 +4246,13 @@ var ClaudeCodeInstaller = class {
     }
     try {
       const writtenFiles = [];
-      await mkdir5(pluginVersionDir, { recursive: true });
+      await mkdir4(pluginVersionDir, { recursive: true });
       writtenFiles.push(pluginVersionDir);
       for (const cap of CAPABILITY_DIRS) {
         const srcDir = resolve9(plugin.sourceDir, cap);
         if (!await dirExists(srcDir)) continue;
         const dstDir = this.paths.capabilityDir(ref, version, cap);
-        await mkdir5(dstDir, { recursive: true });
+        await mkdir4(dstDir, { recursive: true });
         writtenFiles.push(dstDir);
         const copied = await copyDirTracked(srcDir, dstDir);
         writtenFiles.push(...copied);
@@ -4392,8 +4387,8 @@ var ClaudeCodeInstaller = class {
       await unlink(mktDir);
       files.push(mktDir);
     } else if (kind === "dir") {
-      if (await pathExists3(join9(mktDir, ".rush-marketplace-source.json"))) {
-        await rm5(mktDir, { recursive: true, force: true });
+      if (await pathExists(join9(mktDir, ".rush-marketplace-source.json"))) {
+        await rm4(mktDir, { recursive: true, force: true });
         files.push(mktDir);
       }
     }
@@ -4412,7 +4407,7 @@ var ClaudeCodeInstaller = class {
    * 会把自己算作"还有引用"。
    */
   async marketplaceStillReferenced(marketplace) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return false;
     }
     const { data } = await readJsonFile(
@@ -4427,7 +4422,7 @@ var ClaudeCodeInstaller = class {
     return false;
   }
   async removeKnownMarketplaceEntry(marketplace) {
-    if (!await pathExists3(this.paths.knownMarketplacesJson)) {
+    if (!await pathExists(this.paths.knownMarketplacesJson)) {
       return false;
     }
     return retryOnConflict(async () => {
@@ -4464,11 +4459,11 @@ var ClaudeCodeInstaller = class {
       return { written: false, path: "" };
     }
     const mktDir = this.paths.marketplaceInstallDir(marketplaceName);
-    await mkdir5(this.paths.marketplacesRootDir, { recursive: true });
+    await mkdir4(this.paths.marketplacesRootDir, { recursive: true });
     const kind = await inodeKind(mktDir);
     if (kind === "symlink") {
       const target = await readlink(mktDir).catch(() => null);
-      const resolvedTarget = target !== null ? resolve9(dirname5(mktDir), target) : null;
+      const resolvedTarget = target !== null ? resolve9(dirname4(mktDir), target) : null;
       if (resolvedTarget && resolvedTarget === resolve9(src.rootDir)) {
         return { written: false, path: mktDir };
       }
@@ -4478,7 +4473,7 @@ var ClaudeCodeInstaller = class {
     }
     if (kind === "dir") {
       const metaPath = join9(mktDir, ".rush-marketplace-source.json");
-      if (await pathExists3(metaPath)) {
+      if (await pathExists(metaPath)) {
         const metaSourceRaw = await readMarketplaceCacheSource(metaPath);
         const currentSourceRaw = descriptorToSourceRaw(src.descriptor);
         if (metaSourceRaw !== null && metaSourceRaw === currentSourceRaw) {
@@ -4502,7 +4497,7 @@ var ClaudeCodeInstaller = class {
       return { written: true, path: mktDir };
     }
     await copyDirTracked(src.rootDir, mktDir).catch(async (err) => {
-      await rm5(mktDir, { recursive: true, force: true }).catch(() => {
+      await rm4(mktDir, { recursive: true, force: true }).catch(() => {
       });
       throw err;
     });
@@ -4522,7 +4517,7 @@ var ClaudeCodeInstaller = class {
     return [];
   }
   async isAlreadyInstalledAtVersion(ref, version) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return false;
     }
     const { data } = await readJsonFile(
@@ -4576,7 +4571,7 @@ var ClaudeCodeInstaller = class {
     };
   }
   async isKnownMarketplaceRegistered(marketplace) {
-    if (!await pathExists3(this.paths.knownMarketplacesJson)) {
+    if (!await pathExists(this.paths.knownMarketplacesJson)) {
       return false;
     }
     const { data } = await readJsonFile(
@@ -4586,7 +4581,7 @@ var ClaudeCodeInstaller = class {
     return Object.hasOwn(data, marketplace);
   }
   async wouldInstalledPluginsChange(ref, version, installPath) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return true;
     }
     const { data } = await readJsonFile(
@@ -4600,7 +4595,7 @@ var ClaudeCodeInstaller = class {
     return userEntry.version !== version || userEntry.installPath !== installPath;
   }
   async wouldSettingsChange(key) {
-    if (!await pathExists3(this.paths.settingsJson)) {
+    if (!await pathExists(this.paths.settingsJson)) {
       return true;
     }
     const { data } = await readJsonFile(
@@ -4658,8 +4653,8 @@ var ClaudeCodeInstaller = class {
     const settings = await this.readRawJsonForRollback(this.paths.settingsJson);
     let backupVersionDir = null;
     if (preexistedVersion === "dir") {
-      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID4()}`;
-      await rename4(pluginVersionDir, backupVersionDir);
+      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID3()}`;
+      await rename3(pluginVersionDir, backupVersionDir);
     }
     return {
       ref,
@@ -4680,7 +4675,7 @@ var ClaudeCodeInstaller = class {
    */
   async finalizeRollback(snap) {
     if (snap.backupVersionDir) {
-      await rm5(snap.backupVersionDir, { recursive: true, force: true });
+      await rm4(snap.backupVersionDir, { recursive: true, force: true });
     }
   }
   /**
@@ -4693,19 +4688,19 @@ var ClaudeCodeInstaller = class {
    */
   async applyRollback(snap) {
     if (snap.preexistedVersion === "dir" && snap.backupVersionDir) {
-      await rm5(snap.pluginVersionDir, { recursive: true, force: true });
-      await rename4(snap.backupVersionDir, snap.pluginVersionDir);
+      await rm4(snap.pluginVersionDir, { recursive: true, force: true });
+      await rename3(snap.backupVersionDir, snap.pluginVersionDir);
     } else if (snap.preexistedVersion === "missing") {
-      await rm5(snap.pluginVersionDir, { recursive: true, force: true });
+      await rm4(snap.pluginVersionDir, { recursive: true, force: true });
     }
     if (snap.preexistedPlugin === "missing") {
-      await rm5(this.paths.pluginCacheDir(snap.ref), {
+      await rm4(this.paths.pluginCacheDir(snap.ref), {
         recursive: true,
         force: true
       });
     }
     if (snap.preexistedMarketplace === "missing") {
-      await rm5(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
+      await rm4(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
         recursive: true,
         force: true
       });
@@ -4719,7 +4714,7 @@ var ClaudeCodeInstaller = class {
         await unlink(mktInstallDir).catch(() => {
         });
       } else if (currentKind !== "missing") {
-        await rm5(mktInstallDir, { recursive: true, force: true }).catch(
+        await rm4(mktInstallDir, { recursive: true, force: true }).catch(
           () => {
           }
         );
@@ -4730,7 +4725,7 @@ var ClaudeCodeInstaller = class {
     await this.restoreRawJson(this.paths.settingsJson, snap.settings);
   }
   async readRawJsonForRollback(path4) {
-    if (!await pathExists3(path4)) {
+    if (!await pathExists(path4)) {
       return { existed: false };
     }
     const { data } = await readJsonFile(
@@ -4741,8 +4736,8 @@ var ClaudeCodeInstaller = class {
   }
   async restoreRawJson(path4, state) {
     if (!state.existed) {
-      if (await pathExists3(path4)) {
-        await rm5(path4, { force: true });
+      if (await pathExists(path4)) {
+        await rm4(path4, { force: true });
       }
       return;
     }
@@ -4903,7 +4898,7 @@ var ClaudeCodeInstaller = class {
     });
   }
   async removeInstalledPlugin(ref) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return false;
     }
     return retryOnConflict(async () => {
@@ -4933,7 +4928,7 @@ var ClaudeCodeInstaller = class {
     });
   }
   async disablePlugin(key) {
-    if (!await pathExists3(this.paths.settingsJson)) {
+    if (!await pathExists(this.paths.settingsJson)) {
       return false;
     }
     return retryOnConflict(async () => {
@@ -4959,7 +4954,7 @@ var ClaudeCodeInstaller = class {
   }
   /** installed_plugins.json 是否有本 plugin 的 user scope 条目（uninstall dry-run 用） */
   async installedPluginsHasEntry(ref) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return false;
     }
     const { data } = await readJsonFile(
@@ -4972,7 +4967,7 @@ var ClaudeCodeInstaller = class {
   }
   /** settings.json.enabledPlugins 是否有本 key（uninstall dry-run 用） */
   async settingsHasEnabledKey(key) {
-    if (!await pathExists3(this.paths.settingsJson)) {
+    if (!await pathExists(this.paths.settingsJson)) {
       return false;
     }
     const { data } = await readJsonFile(
@@ -4999,7 +4994,7 @@ var ClaudeCodeInstaller = class {
     return Object.keys(servers);
   }
   async findLatestManifestPath(ref) {
-    if (!await pathExists3(this.paths.installedPluginsJson)) {
+    if (!await pathExists(this.paths.installedPluginsJson)) {
       return null;
     }
     const { data } = await readJsonFile(
@@ -5015,7 +5010,7 @@ var ClaudeCodeInstaller = class {
       ".claude-plugin",
       "plugin.json"
     );
-    if (await pathExists3(manifestPath)) {
+    if (await pathExists(manifestPath)) {
       return manifestPath;
     }
     return null;
@@ -5042,7 +5037,7 @@ function buildPluginJson(plugin, mcpServers) {
 }
 async function readMarketplaceCacheSource(metaPath) {
   try {
-    const raw = await readFile6(metaPath, "utf8");
+    const raw = await readFile5(metaPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const sourceRaw = parsed.sourceRaw;
@@ -5077,7 +5072,7 @@ async function defaultSymlinkRunner(target, linkPath) {
 }
 async function dirExists(p) {
   try {
-    const s = await stat3(p);
+    const s = await stat2(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -5117,12 +5112,12 @@ async function copyDirTracked(srcDir, dstDir) {
     const srcPath = join9(srcDir, entry.name);
     const dstPath = join9(dstDir, entry.name);
     if (entry.isDirectory()) {
-      await mkdir5(dstPath, { recursive: true });
+      await mkdir4(dstPath, { recursive: true });
       written.push(dstPath);
       const subWritten = await copyDirTracked(srcPath, dstPath);
       written.push(...subWritten);
     } else if (entry.isFile()) {
-      await mkdir5(dirname5(dstPath), { recursive: true });
+      await mkdir4(dirname4(dstPath), { recursive: true });
       await copyFile(srcPath, dstPath);
       written.push(dstPath);
     }
@@ -5133,7 +5128,7 @@ async function writeAtomicWithMtimeCheck(filePath, data, expectedMtimeMs) {
   if (expectedMtimeMs !== null) {
     let currentMtime = null;
     try {
-      const s = await stat3(filePath);
+      const s = await stat2(filePath);
       currentMtime = s.mtimeMs;
     } catch {
       currentMtime = null;
@@ -5156,19 +5151,27 @@ async function retryOnConflict(fn) {
 }
 
 // src/installers/codex/installer.ts
-import { constants as fsConstants7 } from "fs";
+import { constants as fsConstants6 } from "fs";
 import {
-  access as access7,
+  access as access6,
   cp,
-  mkdir as mkdir7,
+  mkdir as mkdir6,
+  mkdtemp,
   readdir as readdir3,
-  readFile as readFile8,
-  rm as rm7,
-  stat as stat5,
-  writeFile as writeFile6
+  readFile as readFile7,
+  rename as rename5,
+  rm as rm6,
+  stat as stat4,
+  writeFile as writeFile5
 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname7, relative as pathRelative, resolve as resolve10 } from "path";
+import {
+  basename as basename2,
+  dirname as dirname6,
+  extname,
+  relative as pathRelative,
+  resolve as resolve10
+} from "path";
 
 // src/installers/codex/mcp.ts
 import { isAbsolute as isAbsolute3 } from "path";
@@ -5223,6 +5226,18 @@ function codexConfigTomlPath(home) {
 function codexPluginsCacheDir(home) {
   return pathResolve(codexHomeDir(home), "plugins", "cache");
 }
+function codexPluginsMarketplacesDir(home) {
+  return pathResolve(codexHomeDir(home), "plugins", "marketplaces");
+}
+function codexMarketplaceDir(home, marketplace) {
+  return pathResolve(codexPluginsMarketplacesDir(home), marketplace);
+}
+function codexMarketplaceManifestPath(marketplaceDir) {
+  return pathResolve(marketplaceDir, ".agents", "plugins", "marketplace.json");
+}
+function codexMarketplacePluginDir(marketplaceDir, pluginName) {
+  return pathResolve(marketplaceDir, "plugins", pluginName);
+}
 function codexPluginVersionDir(home, ref, version) {
   return pathResolve(
     codexPluginsCacheDir(home),
@@ -5259,19 +5274,19 @@ function pluginSectionKey(ref) {
 }
 
 // src/installers/codex/toml.ts
-import { randomUUID as randomUUID5 } from "crypto";
-import { constants as fsConstants6 } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+import { constants as fsConstants5 } from "fs";
 import {
-  access as access6,
+  access as access5,
   copyFile as copyFile2,
-  mkdir as mkdir6,
-  readFile as readFile7,
-  rename as rename5,
-  rm as rm6,
-  stat as stat4,
-  writeFile as writeFile5
+  mkdir as mkdir5,
+  readFile as readFile6,
+  rename as rename4,
+  rm as rm5,
+  stat as stat3,
+  writeFile as writeFile4
 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname5 } from "path";
 import tomlModule from "@iarna/toml";
 var { parse: tomlParse, stringify: tomlStringify } = tomlModule;
 var CodexConfigTomlError = class extends Error {
@@ -5305,8 +5320,8 @@ async function readCodexConfig(filePath) {
   if (!await pathExists4(filePath)) {
     return { data: {}, mtimeMs: null };
   }
-  const stats = await stat4(filePath);
-  const raw = await readFile7(filePath, "utf8");
+  const stats = await stat3(filePath);
+  const raw = await readFile6(filePath, "utf8");
   try {
     const parsed = tomlParse(raw);
     return { data: parsed, mtimeMs: stats.mtimeMs };
@@ -5320,7 +5335,7 @@ async function backupCodexConfig(filePath, backupPath) {
   }
   let finalBackup = backupPath;
   if (await pathExists4(finalBackup)) {
-    finalBackup = `${backupPath}.${randomUUID5().slice(0, 8)}`;
+    finalBackup = `${backupPath}.${randomUUID4().slice(0, 8)}`;
   }
   await copyFile2(filePath, finalBackup);
   return finalBackup;
@@ -5329,19 +5344,19 @@ async function writeCodexConfig(filePath, data, expectedMtimeMs) {
   await assertNoMtimeDrift(filePath, expectedMtimeMs);
   const serialized = tomlStringify(data);
   await atomicWrite2(filePath, serialized);
-  const afterStats = await stat4(filePath);
+  const afterStats = await stat3(filePath);
   return { mtimeMs: afterStats.mtimeMs };
 }
 async function restoreCodexConfigFromBackup(filePath, backupPath) {
   if (!backupPath || !await pathExists4(backupPath)) {
     if (await pathExists4(filePath)) {
-      await rm6(filePath, { force: true });
+      await rm5(filePath, { force: true });
     }
     return;
   }
-  const raw = await readFile7(backupPath, "utf8");
+  const raw = await readFile6(backupPath, "utf8");
   await atomicWrite2(filePath, raw);
-  await rm6(backupPath, { force: true }).catch(() => {
+  await rm5(backupPath, { force: true }).catch(() => {
   });
 }
 function setMarketplaceSection(config, name, entry) {
@@ -5380,20 +5395,20 @@ function marketplaceHasOtherPlugins(config, marketplaceName, excludedPluginKey)
 }
 async function pathExists4(p) {
   try {
-    await access6(p, fsConstants6.F_OK);
+    await access5(p, fsConstants5.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir6(dirname6(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID5()}.tmp`;
+  await mkdir5(dirname5(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID4()}.tmp`;
   try {
-    await writeFile5(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename5(tmp, filePath);
+    await writeFile4(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename4(tmp, filePath);
   } catch (err) {
-    await rm6(tmp, { force: true }).catch(() => {
+    await rm5(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -5405,7 +5420,7 @@ async function assertNoMtimeDrift(filePath, expectedMtimeMs) {
     }
     return;
   }
-  const current = await stat4(filePath).catch(() => null);
+  const current = await stat3(filePath).catch(() => null);
   if (current === null) {
     throw new CodexConfigTomlConflictError(filePath);
   }
@@ -5429,7 +5444,7 @@ function ensureObjectSection(config, key) {
 }
 
 // src/installers/codex/installer.ts
-var CODEX_UNSUPPORTED = ["commands", "rules", "hooks"];
+var CODEX_UNSUPPORTED = ["rules", "hooks"];
 var CodexInstallError = class extends Error {
   constructor(message) {
     super(message);
@@ -5536,6 +5551,7 @@ var CodexInstaller = class {
     }
     const rollback = {
       createdVersionDir: null,
+      createdMarketplacePluginDir: null,
       backupPath: null,
       preExistingConfig: null
     };
@@ -5650,19 +5666,23 @@ var CodexInstaller = class {
     const ref = plugin.ref;
     const key = pluginSectionKey(ref);
     const versionDir = codexPluginVersionDir(this.home, ref, plugin.version);
+    const marketplaceDir = codexMarketplaceDir(this.home, ref.marketplace);
+    const marketplacePluginDir = codexMarketplacePluginDir(
+      marketplaceDir,
+      ref.name
+    );
     const cfgPath = codexConfigTomlPath(this.home);
     const preExisted = await pathExists5(versionDir);
     if (preExisted) {
-      await rm7(versionDir, { recursive: true, force: true });
+      await rm6(versionDir, { recursive: true, force: true });
     }
-    await mkdir7(versionDir, { recursive: true });
+    await mkdir6(versionDir, { recursive: true });
     rollback.createdVersionDir = versionDir;
-    const srcSkills = resolve10(plugin.sourceDir, "skills");
     const dstSkills = codexPluginSkillsDir(versionDir);
-    const hasSkills2 = await hasNonEmptyDir(srcSkills);
     const writtenFiles = [versionDir];
-    if (hasSkills2) {
-      await cp(srcSkills, dstSkills, { recursive: true });
+    const skillsPlan = await planCodexSkills(plugin);
+    if (skillsPlan.hasSkills) {
+      await materializeCodexSkills(skillsPlan, dstSkills);
       writtenFiles.push(dstSkills);
     }
     let mcpJsonRef;
@@ -5712,11 +5732,10 @@ var CodexInstaller = class {
     rollback.backupPath = actualBackup;
     const { data: config, mtimeMs } = await readCodexConfig(cfgPath);
     rollback.preExistingConfig = mtimeMs !== null;
-    const marketplaceSource = this.resolveMarketplaceSource(plugin);
     setMarketplaceSection(config, ref.marketplace, {
       last_updated: this.now().toISOString(),
-      source_type: marketplaceSource.sourceType,
-      source: marketplaceSource.source
+      source_type: "local",
+      source: marketplaceDir
     });
     setPluginEntry(config, key, { enabled: true });
     await writeCodexConfig(cfgPath, config, mtimeMs);
@@ -5724,6 +5743,18 @@ var CodexInstaller = class {
     if (actualBackup) {
       writtenFiles.push(actualBackup);
     }
+    await writeCodexMarketplaceMirror({
+      marketplaceDir,
+      pluginDir: marketplacePluginDir,
+      plugin,
+      versionDir
+    });
+    rollback.createdMarketplacePluginDir = marketplacePluginDir;
+    writtenFiles.push(
+      marketplaceDir,
+      codexMarketplaceManifestPath(marketplaceDir),
+      marketplacePluginDir
+    );
     const included = computeIncludedCapabilities(plugin);
     const notes = [];
     if (actualBackup) {
@@ -5755,10 +5786,22 @@ var CodexInstaller = class {
   async buildDryRunResult(plugin) {
     const ref = plugin.ref;
     const versionDir = codexPluginVersionDir(this.home, ref, plugin.version);
+    const marketplaceDir = codexMarketplaceDir(this.home, ref.marketplace);
+    const marketplacePluginDir = codexMarketplacePluginDir(
+      marketplaceDir,
+      ref.name
+    );
     const cfgPath = codexConfigTomlPath(this.home);
-    const files = [versionDir, codexPluginManifestPath(versionDir)];
-    const srcSkills = resolve10(plugin.sourceDir, "skills");
-    if (await hasNonEmptyDir(srcSkills)) {
+    const files = [
+      versionDir,
+      codexPluginManifestPath(versionDir),
+      marketplaceDir,
+      codexMarketplaceManifestPath(marketplaceDir),
+      marketplacePluginDir,
+      cfgPath
+    ];
+    const skillsPlan = await planCodexSkills(plugin);
+    if (skillsPlan.hasSkills) {
       files.push(codexPluginSkillsDir(versionDir));
     }
     let mcpKeys = [];
@@ -5781,7 +5824,7 @@ var CodexInstaller = class {
           );
         } else {
           try {
-            const raw = await readFile8(srcPath, "utf8");
+            const raw = await readFile7(srcPath, "utf8");
             const parsed = JSON.parse(raw);
             if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
               mcpKeys = Object.keys(parsed.mcpServers).sort();
@@ -5801,7 +5844,6 @@ var CodexInstaller = class {
         }
       }
     }
-    files.push(cfgPath);
     return {
       target: "codex",
       status: dryRunStatus,
@@ -5812,16 +5854,16 @@ var CodexInstaller = class {
       ...dryRunErrors.length > 0 ? { errors: dryRunErrors } : {}
     };
   }
-  resolveMarketplaceSource(plugin) {
-    if (this.marketplaceSource) {
-      return this.marketplaceSource;
-    }
-    return { sourceType: "local", source: plugin.sourceDir };
-  }
 };
 function computeIncludedCapabilities(plugin) {
-  const supported = ["skills", "mcp"];
-  return supported.filter((cap) => plugin.capabilities.includes(cap));
+  const included = [];
+  if (plugin.capabilities.includes("skills") || plugin.capabilities.includes("commands")) {
+    included.push("skills");
+  }
+  if (plugin.capabilities.includes("mcp")) {
+    included.push("mcp");
+  }
+  return included;
 }
 function buildCodexPluginJson(manifest, mcpServersRef) {
   const out = {
@@ -5838,9 +5880,28 @@ function buildCodexPluginJson(manifest, mcpServersRef) {
   if (mcpServersRef !== void 0) {
     out.mcpServers = mcpServersRef;
   }
-  if (manifest.interface !== void 0) out.interface = manifest.interface;
+  out.interface = buildCodexInterfaceMetadata(manifest);
   return out;
 }
+function buildCodexInterfaceMetadata(manifest) {
+  const existing = manifest.interface ?? {};
+  return {
+    displayName: existing.displayName ?? manifest.name,
+    shortDescription: existing.shortDescription ?? manifest.description ?? manifest.name,
+    longDescription: existing.longDescription ?? manifest.description,
+    developerName: existing.developerName ?? manifest.author?.name,
+    category: existing.category ?? "Engineering",
+    capabilities: existing.capabilities ?? ["Read", "Write"],
+    websiteURL: existing.websiteURL ?? manifest.homepage,
+    privacyPolicyURL: existing.privacyPolicyURL,
+    termsOfServiceURL: existing.termsOfServiceURL,
+    defaultPrompt: existing.defaultPrompt,
+    brandColor: existing.brandColor,
+    composerIcon: existing.composerIcon,
+    logo: existing.logo,
+    screenshots: existing.screenshots
+  };
+}
 async function rollbackInstall(home, rollback) {
   const cfgPath = codexConfigTomlPath(home);
   if (rollback.backupPath) {
@@ -5849,11 +5910,18 @@ async function rollbackInstall(home, rollback) {
       }
     );
   } else if (rollback.preExistingConfig === false) {
-    await rm7(cfgPath, { force: true }).catch(() => {
+    await rm6(cfgPath, { force: true }).catch(() => {
     });
   }
   if (rollback.createdVersionDir) {
-    await rm7(rollback.createdVersionDir, {
+    await rm6(rollback.createdVersionDir, {
+      recursive: true,
+      force: true
+    }).catch(() => {
+    });
+  }
+  if (rollback.createdMarketplacePluginDir) {
+    await rm6(rollback.createdMarketplacePluginDir, {
       recursive: true,
       force: true
     }).catch(() => {
@@ -5898,8 +5966,8 @@ async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
   }
   if (!await pathExists5(srcPath)) return null;
   const destPath = resolve10(versionDir, relativeRef);
-  await mkdir7(dirname7(destPath), { recursive: true });
-  const raw = await readFile8(srcPath, "utf8");
+  await mkdir6(dirname6(destPath), { recursive: true });
+  const raw = await readFile7(srcPath, "utf8");
   await writeFileAtomic(destPath, raw);
   let mcpKeys = [];
   try {
@@ -5912,22 +5980,380 @@ async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
   }
   return { destPath, mcpKeys };
 }
+async function writeCodexMarketplaceMirror(input) {
+  const pluginParent = dirname6(input.pluginDir);
+  const pluginBase = basename2(input.pluginDir);
+  await mkdir6(pluginParent, { recursive: true });
+  const tmpPluginDir = await mkdtemp(
+    resolve10(pluginParent, `.${pluginBase}.tmp-`)
+  );
+  const backupPluginDir = await mkdtemp(
+    resolve10(pluginParent, `.${pluginBase}.bak-`)
+  );
+  let hadExistingPluginDir = false;
+  let swappedPluginDir = false;
+  try {
+    await rm6(tmpPluginDir, { recursive: true, force: true });
+    await rm6(backupPluginDir, { recursive: true, force: true }).catch(() => {
+    });
+    await cp(input.versionDir, tmpPluginDir, {
+      recursive: true,
+      dereference: false,
+      preserveTimestamps: true,
+      verbatimSymlinks: true
+    });
+    hadExistingPluginDir = await pathExists5(input.pluginDir);
+    if (hadExistingPluginDir) {
+      await rename5(input.pluginDir, backupPluginDir);
+    }
+    await rename5(tmpPluginDir, input.pluginDir);
+    swappedPluginDir = true;
+    await upsertCodexMarketplaceManifest(input.marketplaceDir, input.plugin);
+    if (hadExistingPluginDir) {
+      await rm6(backupPluginDir, { recursive: true, force: true });
+    }
+  } catch (err) {
+    await rm6(tmpPluginDir, { recursive: true, force: true }).catch(() => {
+    });
+    let restoredBackup = false;
+    if (hadExistingPluginDir && await pathExists5(backupPluginDir)) {
+      let displacedPluginDir = null;
+      try {
+        if (await pathExists5(input.pluginDir)) {
+          displacedPluginDir = await mkdtemp(
+            resolve10(pluginParent, `.${pluginBase}.failed-`)
+          );
+          await rm6(displacedPluginDir, { recursive: true, force: true });
+          await rename5(input.pluginDir, displacedPluginDir);
+        }
+        await rename5(backupPluginDir, input.pluginDir);
+        restoredBackup = true;
+        if (displacedPluginDir) {
+          await rm6(displacedPluginDir, { recursive: true, force: true }).catch(
+            () => {
+            }
+          );
+        }
+      } catch {
+        if (displacedPluginDir && !await pathExists5(input.pluginDir) && await pathExists5(displacedPluginDir)) {
+          await rename5(displacedPluginDir, input.pluginDir).catch(() => {
+          });
+        }
+      }
+    } else if (swappedPluginDir) {
+      await rm6(input.pluginDir, { recursive: true, force: true }).catch(
+        () => {
+        }
+      );
+    }
+    if (restoredBackup || !hadExistingPluginDir) {
+      await rm6(backupPluginDir, { recursive: true, force: true }).catch(
+        () => {
+        }
+      );
+    }
+    throw err;
+  }
+}
+async function upsertCodexMarketplaceManifest(marketplaceDir, plugin) {
+  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
+  const manifest = await readCodexMarketplaceManifest(manifestPath, {
+    name: plugin.ref.marketplace,
+    interface: {
+      displayName: plugin.ref.marketplace
+    },
+    plugins: []
+  });
+  const plugins = Array.isArray(manifest.plugins) ? manifest.plugins : [];
+  const nextEntry = {
+    name: plugin.ref.name,
+    source: {
+      source: "local",
+      path: `./plugins/${plugin.ref.name}`
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL"
+    },
+    category: buildCodexInterfaceMetadata(plugin.manifest).category
+  };
+  const nextPlugins = [
+    ...plugins.filter((entry) => entry?.name !== plugin.ref.name),
+    nextEntry
+  ].sort((a, b) => a.name.localeCompare(b.name));
+  await writeFileAtomic(
+    manifestPath,
+    `${JSON.stringify({ ...manifest, plugins: nextPlugins }, null, 2)}
+`
+  );
+}
+async function readCodexMarketplaceManifest(manifestPath, fallback) {
+  if (!await pathExists5(manifestPath)) return fallback;
+  try {
+    const parsed = JSON.parse(await readFile7(manifestPath, "utf8"));
+    return {
+      name: typeof parsed.name === "string" ? parsed.name : fallback.name,
+      interface: parsed.interface && typeof parsed.interface === "object" && !Array.isArray(parsed.interface) ? parsed.interface : fallback.interface,
+      plugins: Array.isArray(parsed.plugins) ? parsed.plugins.filter(isMarketplacePluginEntry) : fallback.plugins
+    };
+  } catch {
+    return fallback;
+  }
+}
+function isMarketplacePluginEntry(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string";
+}
+async function planCodexSkills(plugin) {
+  const sources = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  const coveredAliases = /* @__PURE__ */ new Set();
+  const commandFiles = await listMarkdownFiles(
+    resolve10(plugin.sourceDir, "commands"),
+    {
+      recursive: false
+    }
+  );
+  const commandAliases = new Set(
+    await Promise.all(
+      commandFiles.map((file2) => markdownSkillAlias(plugin.manifest.name, file2))
+    )
+  );
+  const nativeSkillsDir = resolve10(plugin.sourceDir, "skills");
+  if (await hasCodexSkillDir(nativeSkillsDir)) {
+    for (const name of await listCodexSkillNames(nativeSkillsDir)) {
+      usedNames.add(name);
+      coveredAliases.add(skillAlias(plugin.manifest.name, name));
+      sources.push({
+        kind: "copy-skill",
+        sourceDir: resolve10(nativeSkillsDir, name),
+        skillName: name
+      });
+    }
+  } else {
+    const dotSkillsDir = resolve10(plugin.sourceDir, ".skills");
+    const claudeSkills = await listMarkdownFiles(dotSkillsDir);
+    const claudeAliases = /* @__PURE__ */ new Map();
+    for (const file2 of claudeSkills) {
+      const alias = await markdownSkillAlias(plugin.manifest.name, file2);
+      claudeAliases.set(alias, (claudeAliases.get(alias) ?? 0) + 1);
+    }
+    for (const file2 of claudeSkills) {
+      const alias = await markdownSkillAlias(plugin.manifest.name, file2);
+      if (commandAliases.has(alias)) {
+        continue;
+      }
+      const uniqueAlias = (claudeAliases.get(alias) ?? 0) > 1 ? markdownPathAlias(plugin.manifest.name, dotSkillsDir, file2) : alias;
+      const skillName = uniqueSkillName(
+        usedNames,
+        `${plugin.manifest.name}-${uniqueAlias}`
+      );
+      coveredAliases.add(alias);
+      coveredAliases.add(uniqueAlias);
+      sources.push({ kind: "markdown", sourceFile: file2, skillName });
+    }
+  }
+  for (const file2 of commandFiles) {
+    const alias = await markdownSkillAlias(plugin.manifest.name, file2);
+    if (coveredAliases.has(alias)) {
+      continue;
+    }
+    const skillName = uniqueSkillName(
+      usedNames,
+      `${plugin.manifest.name}-${alias}`
+    );
+    coveredAliases.add(alias);
+    sources.push({ kind: "markdown", sourceFile: file2, skillName });
+  }
+  return { sources, hasSkills: sources.length > 0 };
+}
+async function materializeCodexSkills(plan, dstSkills) {
+  for (const source of plan.sources) {
+    if (source.kind === "copy-skill") {
+      await cp(source.sourceDir, resolve10(dstSkills, source.skillName), {
+        recursive: true,
+        dereference: false,
+        preserveTimestamps: true,
+        verbatimSymlinks: true
+      });
+      continue;
+    }
+    const raw = await readFile7(source.sourceFile, "utf8");
+    const normalized = normalizeSkillMarkdown(raw, source.skillName);
+    await writeFileAtomic(
+      resolve10(dstSkills, source.skillName, "SKILL.md"),
+      normalized
+    );
+  }
+}
+function normalizeSkillMarkdown(raw, skillName) {
+  const text = raw.replace(/\r\n/g, "\n");
+  const parsed = splitMarkdownFrontmatter(text);
+  if (parsed) {
+    const lines = parsed.frontmatter.split("\n");
+    const hasName = lines.some((line) => /^name:\s*/.test(line));
+    const nextLines = hasName ? lines.map(
+      (line) => /^name:\s*/.test(line) ? `name: ${skillName}` : line
+    ) : [`name: ${skillName}`, ...lines];
+    const frontmatter = nextLines.join("\n");
+    const next = `---
+${frontmatter}${frontmatter.endsWith("\n") ? "" : "\n"}${parsed.afterFrontmatter}`;
+    return next.endsWith("\n") ? next : `${next}
+`;
+  }
+  return `---
+name: ${skillName}
+description: ${firstMarkdownLine(raw) ?? skillName}
+---
+
+${text.endsWith("\n") ? text : `${text}
+`}`;
+}
+function splitMarkdownFrontmatter(text) {
+  if (!text.startsWith("---\n")) return null;
+  const lines = text.split("\n");
+  if (lines[0] !== "---") return null;
+  let blockScalarIndent = null;
+  for (let i = 1; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const indent = leadingSpaces(line);
+    if (blockScalarIndent !== null) {
+      if (line.trim() === "" || indent > blockScalarIndent) {
+        continue;
+      }
+      blockScalarIndent = null;
+    }
+    if (line === "---") {
+      return {
+        frontmatter: lines.slice(1, i).join("\n"),
+        afterFrontmatter: lines.slice(i).join("\n")
+      };
+    }
+    if (/^[A-Za-z0-9_.-]+:\s*[|>]/.test(line)) {
+      blockScalarIndent = indent;
+    }
+  }
+  return null;
+}
+function leadingSpaces(value) {
+  const match = value.match(/^ */);
+  return match?.[0].length ?? 0;
+}
+function frontmatterValue(frontmatter, key) {
+  for (const line of frontmatter.split("\n")) {
+    const match = line.match(/^([A-Za-z0-9_.-]+):\s*(.*)$/);
+    if (match?.[1] === key) {
+      return match[2]?.trim() ?? "";
+    }
+  }
+  return null;
+}
+function firstMarkdownLine(raw) {
+  const line = raw.split(/\r?\n/).map((value) => value.trim()).find((value) => value.length > 0 && value !== "---");
+  if (!line) return null;
+  return line.replace(/^#+\s*/, "").slice(0, 140);
+}
+async function hasCodexSkillDir(skillsDir) {
+  return (await listCodexSkillNames(skillsDir)).length > 0;
+}
+async function listCodexSkillNames(skillsDir) {
+  if (!await isDir(skillsDir)) return [];
+  let entries;
+  try {
+    entries = await readdir3(skillsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const names = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (await pathExists5(resolve10(skillsDir, entry.name, "SKILL.md"))) {
+      names.push(entry.name);
+    }
+  }
+  return names.sort();
+}
+async function listMarkdownFiles(dir, opts = {}) {
+  if (!await isDir(dir)) return [];
+  const recursive = opts.recursive !== false;
+  const out = [];
+  async function walk2(current) {
+    let entries;
+    try {
+      entries = await readdir3(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = resolve10(current, entry.name);
+      if (entry.isDirectory()) {
+        if (recursive) await walk2(abs);
+        continue;
+      }
+      if (entry.isFile() && extname(entry.name).toLowerCase() === ".md") {
+        out.push(abs);
+      }
+    }
+  }
+  await walk2(dir);
+  return out.sort();
+}
+function uniqueSkillName(used, desired) {
+  const base = desired.length > 0 ? desired : "skill";
+  let candidate = base;
+  let i = 2;
+  while (used.has(candidate)) {
+    candidate = `${base}-${i}`;
+    i += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+async function markdownSkillAlias(pluginName, filePath) {
+  const triggerAlias = extractTriggerAlias(await readFile7(filePath, "utf8"));
+  return skillAlias(
+    pluginName,
+    triggerAlias ?? basename2(filePath, extname(filePath))
+  );
+}
+function markdownPathAlias(pluginName, baseDir, filePath) {
+  const rel = pathRelative(baseDir, filePath);
+  return skillAlias(pluginName, rel.slice(0, -extname(rel).length));
+}
+function skillAlias(pluginName, value) {
+  let alias = slugify(value);
+  const pluginPrefix = `${slugify(pluginName)}-`;
+  if (alias.startsWith(pluginPrefix)) {
+    alias = alias.slice(pluginPrefix.length);
+  }
+  return alias.length > 0 ? alias : "skill";
+}
+function extractTriggerAlias(raw) {
+  const parsed = splitMarkdownFrontmatter(raw.replace(/\r\n/g, "\n"));
+  const trigger = parsed ? frontmatterValue(parsed.frontmatter, "trigger") : null;
+  if (!trigger) return null;
+  const match = trigger.match(/\/[A-Za-z0-9_.-]+:([A-Za-z0-9_.-]+)/);
+  return match?.[1] ?? null;
+}
+function slugify(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : "skill";
+}
 async function writeFileAtomic(filePath, content) {
-  await mkdir7(dirname7(filePath), { recursive: true });
+  await mkdir6(dirname6(filePath), { recursive: true });
   const tmp = `${filePath}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
+    await writeFile5(tmp, content, { encoding: "utf8", flag: "w" });
     const { rename: rename8 } = await import("fs/promises");
     await rename8(tmp, filePath);
   } catch (err) {
-    await rm7(tmp, { force: true }).catch(() => {
+    await rm6(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function pathExists5(p) {
   try {
-    await access7(p, fsConstants7.F_OK);
+    await access6(p, fsConstants6.F_OK);
     return true;
   } catch {
     return false;
@@ -5935,21 +6361,12 @@ async function pathExists5(p) {
 }
 async function isDir(p) {
   try {
-    const s = await stat5(p);
+    const s = await stat4(p);
     return s.isDirectory();
   } catch {
     return false;
   }
 }
-async function hasNonEmptyDir(p) {
-  if (!await isDir(p)) return false;
-  try {
-    const entries = await readdir3(p);
-    return entries.length > 0;
-  } catch {
-    return false;
-  }
-}
 function dedup(arr) {
   return Array.from(new Set(arr));
 }
@@ -5979,10 +6396,10 @@ async function detectInstalledVersion(home, ref) {
     const manifestPath = resolve10(versionDir, ".codex-plugin", "plugin.json");
     if (!await pathExists5(manifestPath)) continue;
     try {
-      const raw = await readFile8(manifestPath, "utf8");
+      const raw = await readFile7(manifestPath, "utf8");
       const obj = JSON.parse(raw);
       const version = typeof obj.version === "string" && obj.version.length > 0 ? obj.version : entry;
-      const s = await stat5(versionDir);
+      const s = await stat4(versionDir);
       if (!best || s.mtimeMs > best.mtimeMs) {
         best = { version, mtimeMs: s.mtimeMs };
       }
@@ -6004,20 +6421,20 @@ function defaultRushAiBinaryResolver() {
 }
 
 // src/installers/cursor/installer.ts
-import { randomUUID as randomUUID7 } from "crypto";
-import { constants as fsConstants9 } from "fs";
+import { randomUUID as randomUUID6 } from "crypto";
+import { constants as fsConstants8 } from "fs";
 import {
-  access as access9,
+  access as access8,
   cp as cp2,
-  mkdir as mkdir9,
-  readFile as readFile11,
+  mkdir as mkdir8,
+  readFile as readFile10,
   rename as rename7,
-  rm as rm9,
-  stat as stat7,
-  writeFile as writeFile8
+  rm as rm8,
+  stat as stat6,
+  writeFile as writeFile7
 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname9, relative, resolve as resolve13 } from "path";
+import { dirname as dirname8, relative, resolve as resolve13 } from "path";
 
 // src/installers/cursor/marker.ts
 var RUSH_AI_MARKER = "<!-- rush-ai:auto-generated -->";
@@ -6026,18 +6443,18 @@ function hasRushAiMarker(fileContent) {
 }
 
 // src/installers/cursor/mcp.ts
-import { randomUUID as randomUUID6 } from "crypto";
-import { constants as fsConstants8 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { constants as fsConstants7 } from "fs";
 import {
-  access as access8,
-  mkdir as mkdir8,
-  readFile as readFile9,
+  access as access7,
+  mkdir as mkdir7,
+  readFile as readFile8,
   rename as rename6,
-  rm as rm8,
-  stat as stat6,
-  writeFile as writeFile7
+  rm as rm7,
+  stat as stat5,
+  writeFile as writeFile6
 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname7 } from "path";
 async function readCursorMcpJson(filePath) {
   return (await readCursorMcpJsonWithMtime(filePath)).data;
 }
@@ -6045,8 +6462,8 @@ async function readCursorMcpJsonWithMtime(filePath) {
   if (!await pathExists6(filePath)) {
     return { data: {}, mtimeMs: null };
   }
-  const stats = await stat6(filePath);
-  const raw = await readFile9(filePath, "utf8");
+  const stats = await stat5(filePath);
+  const raw = await readFile8(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -6113,22 +6530,22 @@ function removeMcpServers(current, keysToRemove) {
   return cloned;
 }
 async function writeCursorMcpJson(filePath, data) {
-  await mkdir8(dirname8(filePath), { recursive: true });
+  await mkdir7(dirname7(filePath), { recursive: true });
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  const tmp = `${filePath}.${randomUUID6()}.tmp`;
+  const tmp = `${filePath}.${randomUUID5()}.tmp`;
   try {
-    await writeFile7(tmp, content, { encoding: "utf8", flag: "w" });
+    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
     await rename6(tmp, filePath);
   } catch (err) {
-    await rm8(tmp, { force: true }).catch(() => {
+    await rm7(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function pathExists6(p) {
   try {
-    await access8(p, fsConstants8.F_OK);
+    await access7(p, fsConstants7.F_OK);
     return true;
   } catch {
     return false;
@@ -6264,13 +6681,13 @@ function quoteIfNeeded(value) {
 }
 
 // src/installers/cursor/skills.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { resolve as resolve12 } from "path";
 async function readSkillDescription(skillSourceDir) {
   const skillMdPath = resolve12(skillSourceDir, "SKILL.md");
   let raw;
   try {
-    raw = await readFile10(skillMdPath, "utf8");
+    raw = await readFile9(skillMdPath, "utf8");
   } catch {
     return void 0;
   }
@@ -6300,11 +6717,11 @@ async function executeRollback(ledger) {
       if (entry.kind === "restore-file") {
         await atomicWriteFile(entry.path, entry.originalContent);
       } else if (entry.kind === "remove-file") {
-        await rm9(entry.path, { force: true });
+        await rm8(entry.path, { force: true });
       } else if (entry.kind === "remove-dir") {
-        await rm9(entry.path, { recursive: true, force: true });
+        await rm8(entry.path, { recursive: true, force: true });
       } else {
-        await rm9(entry.path, { recursive: true, force: true });
+        await rm8(entry.path, { recursive: true, force: true });
         await safeRename(entry.backupPath, entry.path);
       }
     } catch (err) {
@@ -6316,20 +6733,20 @@ async function executeRollback(ledger) {
   return errors;
 }
 async function atomicWriteFile(filePath, content) {
-  await mkdir9(dirname9(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID7()}.tmp`;
+  await mkdir8(dirname8(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID6()}.tmp`;
   try {
-    await writeFile8(tmp, content, { encoding: "utf8", flag: "w" });
+    await writeFile7(tmp, content, { encoding: "utf8", flag: "w" });
     await rename7(tmp, filePath);
   } catch (err) {
-    await rm9(tmp, { force: true }).catch(() => {
+    await rm8(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function getMcpMtimeMs(filePath) {
   try {
-    const s = await stat7(filePath);
+    const s = await stat6(filePath);
     return s.mtimeMs;
   } catch {
     return null;
@@ -6562,13 +6979,13 @@ var CursorInstaller = class {
       if (info === "missing") continue;
       if (info === "skill-dir") {
         if (!dryRun) {
-          await rm9(filePath, { recursive: true, force: true });
+          await rm8(filePath, { recursive: true, force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (info === "mdc-file") {
-        const content = await readFile11(filePath, "utf8").catch(() => "");
+        const content = await readFile10(filePath, "utf8").catch(() => "");
         if (!hasRushAiMarker(content)) {
           warnings.push(
             `${filePath} \u5DF2\u88AB\u4FEE\u6539\uFF08marker \u4E22\u5931\uFF09\uFF0C\u8DF3\u8FC7\u4E0D\u52A8\u2014\u2014\u8BF7\u7528\u6237\u624B\u52A8\u5904\u7406`
@@ -6576,13 +6993,13 @@ var CursorInstaller = class {
           continue;
         }
         if (!dryRun) {
-          await rm9(filePath, { force: true });
+          await rm8(filePath, { force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (!dryRun) {
-        await rm9(filePath, { force: true });
+        await rm8(filePath, { force: true });
       }
       removedFiles.push(filePath);
     }
@@ -6677,7 +7094,7 @@ var CursorInstaller = class {
             `rule "${ruleName}" \u4E0E skill "${ruleName}" \u7684 bridge rule \u540C\u540D\uFF0Crule \u5185\u5BB9\u4F1A\u8986\u76D6 bridge rule`
           );
         }
-        const src = await readFile11(srcPath, "utf8");
+        const src = await readFile10(srcPath, "utf8");
         const parsed = parseMarkdown(src);
         const content = renderMdc(parsed, {
           descriptionFallback: plugin.manifest.description ?? ruleName
@@ -6705,7 +7122,7 @@ var CursorInstaller = class {
   // -------------------------------------------------------------------------
   async writeSkillDir(args) {
     const preExisted = await dirExists2(args.destDir);
-    await mkdir9(dirname9(args.destDir), { recursive: true });
+    await mkdir8(dirname8(args.destDir), { recursive: true });
     if (preExisted) {
       const backup = `${args.destDir}.${process.pid}.${Date.now()}.bak`;
       await safeRename(args.destDir, backup);
@@ -6722,7 +7139,7 @@ var CursorInstaller = class {
   async writeMdcFile(args) {
     const preExisted = await fileExists(args.path);
     if (preExisted) {
-      const original = await readFile11(args.path, "utf8");
+      const original = await readFile10(args.path, "utf8");
       args.ledger.push({
         kind: "restore-file",
         path: args.path,
@@ -6736,7 +7153,7 @@ var CursorInstaller = class {
   async writeMcpMerge(args) {
     const preExisted = await fileExists(args.mcpPath);
     if (preExisted) {
-      const original = await readFile11(args.mcpPath, "utf8");
+      const original = await readFile10(args.mcpPath, "utf8");
       args.ledger.push({
         kind: "restore-file",
         path: args.mcpPath,
@@ -6820,7 +7237,7 @@ function skippedResult() {
 }
 async function assertMdcWritable(path4, force) {
   if (!await fileExists(path4)) return;
-  const raw = await readFile11(path4, "utf8").catch(() => "");
+  const raw = await readFile10(path4, "utf8").catch(() => "");
   if (hasRushAiMarker(raw)) return;
   if (force) return;
   throw new CursorInstallConflictError(
@@ -6854,7 +7271,7 @@ async function listRuleMdFiles(rulesDir) {
 }
 async function dirExists2(p) {
   try {
-    const s = await stat7(p);
+    const s = await stat6(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -6862,8 +7279,8 @@ async function dirExists2(p) {
 }
 async function fileExists(p) {
   try {
-    await access9(p, fsConstants9.F_OK);
-    const s = await stat7(p);
+    await access8(p, fsConstants8.F_OK);
+    const s = await stat6(p);
     return s.isFile();
   } catch {
     return false;
@@ -6876,7 +7293,7 @@ async function safeRename(from, to) {
 async function classifyArtifactPath(p) {
   let s;
   try {
-    s = await stat7(p);
+    s = await stat6(p);
   } catch {
     return "missing";
   }
@@ -6889,12 +7306,12 @@ async function classifyArtifactPath(p) {
 }
 
 // src/migration/cleanup.ts
-import { lstat as lstat3, rm as rm10, unlink as unlink2 } from "fs/promises";
+import { lstat as lstat3, rm as rm9, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { resolve as resolve15 } from "path";
 
 // src/migration/detect.ts
-import { access as access10, lstat as lstat2, readFile as readFile12, readlink as readlink2, stat as stat8 } from "fs/promises";
+import { access as access9, lstat as lstat2, readFile as readFile11, readlink as readlink2, stat as stat7 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { isAbsolute as isAbsolute4, resolve as resolve14 } from "path";
 var LEGACY_ASSET_MANIFEST_RELATIVE = ".rush/plugins/claude-code/asset-manifest.json";
@@ -6904,7 +7321,7 @@ var LEGACY_SKILL_SYMLINK_RELATIVE = ".claude/skills/rush-task";
 var CLAUDE_SETTINGS_JSON_RELATIVE = ".claude/settings.json";
 async function pathExists7(p) {
   try {
-    await access10(p);
+    await access9(p);
     return true;
   } catch {
     return false;
@@ -6924,7 +7341,7 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
 async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
   try {
     if (!await pathExists7(settingsJsonPath)) return false;
-    const raw = await readFile12(settingsJsonPath, "utf8");
+    const raw = await readFile11(settingsJsonPath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -6972,9 +7389,9 @@ async function detectLegacyVersion(opts = {}) {
   const home = opts.home ?? homedir8();
   const manifestPath = resolve14(home, LEGACY_ASSET_MANIFEST_RELATIVE);
   try {
-    const lst = await stat8(manifestPath);
+    const lst = await stat7(manifestPath);
     if (!lst.isFile()) return "0.7.x";
-    const raw = await readFile12(manifestPath, "utf8");
+    const raw = await readFile11(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.version;
@@ -6990,7 +7407,7 @@ async function detectLegacyVersion(opts = {}) {
 async function cleanupLegacyDir(home) {
   const dir = resolve15(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
   try {
-    await rm10(dir, { recursive: true, force: true });
+    await rm9(dir, { recursive: true, force: true });
     return { ok: true };
   } catch (err) {
     return {
@@ -7078,9 +7495,9 @@ function errorMessage(err) {
 }
 
 // src/migration/log.ts
-import { appendFile as appendFile2, mkdir as mkdir10 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir9 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname10, resolve as resolve16 } from "path";
+import { dirname as dirname9, resolve as resolve16 } from "path";
 var MIGRATION_LOG_RELATIVE_PATH = ".rush/plugins/migration-failed.log";
 function resolveMigrationLogPath(opts = {}) {
   const home = opts.home ?? homedir10();
@@ -7101,14 +7518,14 @@ async function appendMigrationFailure(reason, opts = {}) {
   const payload = `${lines.join("\n")}
 `;
   try {
-    await mkdir10(dirname10(logPath), { recursive: true });
+    await mkdir9(dirname9(logPath), { recursive: true });
     await appendFile2(logPath, payload, { encoding: "utf8" });
   } catch {
   }
 }
 
 // src/migration/migrate.ts
-import { access as access13, readFile as readFile14 } from "fs/promises";
+import { access as access12, readFile as readFile13 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 
 // src/plugins/resolver.ts
@@ -7120,9 +7537,9 @@ import {
 } from "path";
 
 // src/plugins/capabilities.ts
-import { constants as fsConstants10 } from "fs";
-import { access as access11, readdir as readdir4, stat as stat9 } from "fs/promises";
-import { extname, resolve as resolve17 } from "path";
+import { constants as fsConstants9 } from "fs";
+import { access as access10, readdir as readdir4, stat as stat8 } from "fs/promises";
+import { extname as extname2, resolve as resolve17 } from "path";
 var CAPABILITY_ORDER = [
   "commands",
   "skills",
@@ -7155,23 +7572,22 @@ async function hasCommands(sourceDir) {
 }
 async function hasSkills(sourceDir) {
   const skillsDir = resolve17(sourceDir, "skills");
-  if (!await dirExists3(skillsDir)) {
-    return false;
-  }
-  let entries;
-  try {
-    entries = await readdir4(skillsDir, { withFileTypes: true });
-  } catch {
-    return false;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillMdPath = resolve17(skillsDir, entry.name, "SKILL.md");
-    if (await fileExists2(skillMdPath)) {
-      return true;
+  if (await dirExists3(skillsDir)) {
+    let entries;
+    try {
+      entries = await readdir4(skillsDir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillMdPath = resolve17(skillsDir, entry.name, "SKILL.md");
+      if (await fileExists2(skillMdPath)) {
+        return true;
+      }
     }
   }
-  return false;
+  return hasClaudeStyleSkills(sourceDir);
 }
 async function hasRules(sourceDir) {
   return dirHasFileWithExt(resolve17(sourceDir, "rules"), ".md");
@@ -7189,7 +7605,7 @@ async function hasHooks(sourceDir) {
   }
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    if (HOOK_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
+    if (HOOK_EXTENSIONS.has(extname2(entry.name).toLowerCase())) {
       return true;
     }
   }
@@ -7215,12 +7631,38 @@ async function dirHasFileWithExt(dirPath, ext) {
   }
   const target = ext.toLowerCase();
   return entries.some(
-    (e) => e.isFile() && extname(e.name).toLowerCase() === target
+    (e) => e.isFile() && extname2(e.name).toLowerCase() === target
   );
 }
+async function hasClaudeStyleSkills(sourceDir) {
+  const dotSkillsDir = resolve17(sourceDir, ".skills");
+  if (!await dirExists3(dotSkillsDir)) {
+    return false;
+  }
+  async function walk2(dirPath) {
+    let entries;
+    try {
+      entries = await readdir4(dirPath, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      const abs = resolve17(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (await walk2(abs)) return true;
+        continue;
+      }
+      if (entry.isFile() && extname2(entry.name).toLowerCase() === ".md") {
+        return true;
+      }
+    }
+    return false;
+  }
+  return walk2(dotSkillsDir);
+}
 async function dirExists3(p) {
   try {
-    const s = await stat9(p);
+    const s = await stat8(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -7228,8 +7670,8 @@ async function dirExists3(p) {
 }
 async function fileExists2(p) {
   try {
-    await access11(p, fsConstants10.R_OK);
-    const s = await stat9(p);
+    await access10(p, fsConstants9.R_OK);
+    const s = await stat8(p);
     return s.isFile();
   } catch {
     return false;
@@ -7298,18 +7740,18 @@ var InvalidPluginVersionError = class extends PluginResolverError {
 };
 
 // src/plugins/manifest.ts
-import { constants as fsConstants11 } from "fs";
-import { access as access12, readFile as readFile13 } from "fs/promises";
+import { constants as fsConstants10 } from "fs";
+import { access as access11, readFile as readFile12 } from "fs/promises";
 import { resolve as resolve18 } from "path";
 var PLUGIN_MANIFEST_RELATIVE_PATH = ".claude-plugin/plugin.json";
 async function readPluginManifest(pluginName, sourceDir) {
   const manifestPath = resolve18(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
   try {
-    await access12(manifestPath, fsConstants11.R_OK);
+    await access11(manifestPath, fsConstants10.R_OK);
   } catch {
     throw new PluginManifestNotFoundError(pluginName, manifestPath);
   }
-  const raw = await readFile13(manifestPath, "utf8");
+  const raw = await readFile12(manifestPath, "utf8");
   return parsePluginManifest(pluginName, raw, manifestPath);
 }
 function parsePluginManifest(pluginName, raw, sourcePathForError) {
@@ -7705,7 +8147,7 @@ function isTruthyEnvValue(value) {
 }
 async function verifyNewFormat(manifestPath, expectedName, _expectedVersion) {
   try {
-    await access13(manifestPath);
+    await access12(manifestPath);
   } catch (err) {
     return {
       ok: false,
@@ -7714,7 +8156,7 @@ async function verifyNewFormat(manifestPath, expectedName, _expectedVersion) {
   }
   let raw;
   try {
-    raw = await readFile14(manifestPath, "utf8");
+    raw = await readFile13(manifestPath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -8827,7 +9269,7 @@ function registerPluginCommand(program) {
 
 // src/commands/skill/index.ts
 import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync7 } from "fs";
-import { basename as basename2, resolve as resolve19 } from "path";
+import { basename as basename3, resolve as resolve19 } from "path";
 var SKILL_DESCRIPTION = "Print agent usage skills (hand-off, agent-shelf, ...) as raw markdown.";
 var SKILL_HELP_AFTER = `
 Examples:
@@ -8856,7 +9298,7 @@ function resolveSkillsDir() {
   return null;
 }
 function listSkills(dir) {
-  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => basename2(f, ".md")).sort();
+  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => basename3(f, ".md")).sort();
 }
 function registerSkillCommand(program) {
   program.command("skill [name]").description(SKILL_DESCRIPTION).addHelpText("after", SKILL_HELP_AFTER).option("--list", "List available skill names and exit").action((name, opts) => {
@@ -8887,7 +9329,7 @@ function registerSkillCommand(program) {
 
 // src/commands/task/index.ts
 import { createWriteStream } from "fs";
-import { mkdir as mkdir11, readFile as readFile15, stat as stat10 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile14, stat as stat9 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
@@ -10419,7 +10861,7 @@ async function downloadFile(file2, destPath, client) {
   if (!response.body) {
     throw new Error("No response body");
   }
-  await mkdir11(path3.dirname(destPath), { recursive: true });
+  await mkdir10(path3.dirname(destPath), { recursive: true });
   const nodeStream = Readable.fromWeb(
     response.body
   );
@@ -10490,7 +10932,7 @@ function registerTaskCommand(program) {
     }
   );
   task.command("send").description("Send a message to an existing task").argument("<id>", "Task ID (project ID)").option("-p, --prompt <text>", "Message to send").option("--skills <skills>", "Comma-separated skills to add", commaSplit).option("--mcp <servers>", "Comma-separated MCP servers to add", commaSplit).option(
-    "-f, --file <path>",
+    "--file <path>",
     "Attach a local file as context for the agent (repeatable)",
     collectFile,
     []
@@ -10959,7 +11401,7 @@ async function uploadFileForTask(client, localPath) {
   const resolved = path3.resolve(localPath);
   let fileStat;
   try {
-    fileStat = await stat10(resolved);
+    fileStat = await stat9(resolved);
   } catch {
     throw new RushError(`File not found: ${localPath}`);
   }
@@ -10973,7 +11415,7 @@ async function uploadFileForTask(client, localPath) {
   }
   const filename = path3.basename(resolved);
   const mediaType = guessMediaType(resolved);
-  const buf = await readFile15(resolved);
+  const buf = await readFile14(resolved);
   const blob = new File([buf], filename, { type: mediaType });
   const formData = new FormData();
   formData.append("file", blob);
@@ -11025,9 +11467,9 @@ function registerCommands(program) {
 }
 
 // src/util/update-check.ts
-import { mkdir as mkdir12, readFile as readFile16, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname11, join as join10 } from "path";
+import { dirname as dirname10, join as join10 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var REGISTRY_URL = "https://registry.npmjs.org/rush-ai/latest";
@@ -11050,8 +11492,8 @@ function isNewerVersion(current, latest) {
 }
 async function writeLastCheck(checkFile) {
   try {
-    await mkdir12(dirname11(checkFile), { recursive: true });
-    await writeFile9(checkFile, JSON.stringify({ lastCheck: Date.now() }));
+    await mkdir11(dirname10(checkFile), { recursive: true });
+    await writeFile8(checkFile, JSON.stringify({ lastCheck: Date.now() }));
   } catch {
   }
 }
@@ -11062,7 +11504,7 @@ async function checkForUpdate(currentVersion) {
     if (process.env.CI) return;
     let lastCheck = 0;
     try {
-      const data = JSON.parse(await readFile16(checkFile, "utf-8"));
+      const data = JSON.parse(await readFile15(checkFile, "utf-8"));
       lastCheck = data.lastCheck ?? 0;
     } catch {
     }