rush-ai 0.18.0 → 0.19.0

package/dist/index.js

@@ -1,4 +1,38 @@
 #!/usr/bin/env node
+import {
+  backupCodexConfig,
+  codexConfigBackupPath,
+  codexConfigTomlPath,
+  codexHomeDir,
+  codexMarketplaceDir,
+  codexMarketplaceManifestPath,
+  codexMarketplacePluginDir,
+  codexPluginManifestPath,
+  codexPluginMcpPath,
+  codexPluginSkillsDir,
+  codexPluginVersionDir,
+  downgradeCodexCatalogEntryToStub,
+  getMcpServerOwner,
+  pluginSectionKey,
+  readCodexConfig,
+  removeMarketplaceSection,
+  removeMcpServerSection,
+  removePluginEntry,
+  restoreCodexConfigFromBackup,
+  setMarketplaceSection,
+  setMcpServerSection,
+  setPluginEntry,
+  syncCodexMarketplaceMirror,
+  writeCodexConfig,
+  writeCodexMarketplacePluginMirror
+} from "./chunk-RLKEUPBP.js";
+import {
+  SkillAuthError,
+  fetchRushMarketplace,
+  fetchRushPlugin,
+  materializeRushPlugin,
+  pickContentLoader
+} from "./chunk-2AICQRQP.js";
 import {
   consumeSSEStreamWithReconnect
 } from "./chunk-MG4HY2PD.js";
@@ -15,9 +49,15 @@ import {
   RushError,
   TaskFailedError,
   VERSION,
+  createClient,
+  isRushError,
+  revokeCurrentSession,
+  setVerbosity,
+  verifyCurrentAuthSession
+} from "./chunk-E6OSONYW.js";
+import {
   checkAuthSourceMismatch,
   clearAuthConfig,
-  createClient,
   createProfile,
   deleteProfile,
   getActiveProfile,
@@ -29,16 +69,19 @@ import {
   getProfileAuth,
   getProfileConfig,
   isLoggedIn,
-  isRushError,
   listProfiles,
-  output,
-  revokeCurrentSession,
   setActiveProfile,
   setAuthConfig,
-  setGlobalConfig,
-  setVerbosity,
-  verifyCurrentAuthSession
-} from "./chunk-YKZIRW26.js";
+  setGlobalConfig
+} from "./chunk-OIKYNVKO.js";
+import {
+  output
+} from "./chunk-T5S6NCHZ.js";
+import {
+  defaultRushBinaryResolver,
+  normalizeClaudeMcpServers,
+  readExternalMcpServers
+} from "./chunk-X45FKY3L.js";
 
 // src/index.ts
 import chalk7 from "chalk";
@@ -403,7 +446,7 @@ function getApiBaseUrl() {
 async function loginViaBrowser(jsonMode) {
   const baseUrl = getApiBaseUrl();
   const state = randomBytes(16).toString("hex");
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve23, reject) => {
     let authSaved = false;
     const rejectLogin = (error) => {
       clearAuthConfig();
@@ -506,7 +549,7 @@ async function loginViaBrowser(jsonMode) {
             );
           }
         }
-        resolve25();
+        resolve23();
       } catch (err) {
         server.close();
         const authError = err instanceof AuthError ? err : new AuthError(
@@ -2385,24 +2428,24 @@ function registerDoctorCommand(program) {
 import { homedir as homedir5 } from "os";
 
 // src/installers/codex/installer.ts
-import { constants as fsConstants3 } from "fs";
+import { constants as fsConstants } from "fs";
 import {
-  access as access3,
-  cp as cp2,
-  mkdir as mkdir4,
-  readdir as readdir2,
-  readFile as readFile4,
-  rm as rm3,
-  stat as stat3,
-  writeFile as writeFile4
+  access,
+  cp,
+  mkdir as mkdir2,
+  readdir,
+  readFile as readFile2,
+  rm,
+  stat,
+  writeFile as writeFile2
 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import {
-  basename as basename3,
-  dirname as dirname4,
+  basename as basename2,
+  dirname as dirname2,
   extname,
   relative as pathRelative,
-  resolve as resolve4
+  resolve as resolve3
 } from "path";
 
 // src/installers/codex/mcp.ts
@@ -2485,1092 +2528,135 @@ function buildCodexMcpServerTomlEntry(config, options = {}) {
   return null;
 }
 
-// src/installers/codex/mirror.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { constants as fsConstants2 } from "fs";
-import {
-  access as access2,
-  cp,
-  mkdir as mkdir3,
-  mkdtemp,
-  readdir,
-  readFile as readFile3,
-  rename as rename2,
-  rm as rm2,
-  stat as stat2,
-  writeFile as writeFile3
-} from "fs/promises";
-import { basename as basename2, dirname as dirname3, resolve as resolve3 } from "path";
-
-// src/installers/codex/paths.ts
-import { resolve as pathResolve } from "path";
-function codexHomeDir(home) {
-  return pathResolve(home, ".codex");
-}
-function codexConfigTomlPath(home) {
-  return pathResolve(codexHomeDir(home), "config.toml");
-}
-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),
-    ref.marketplace,
-    ref.name,
-    version
-  );
-}
-function codexPluginManifestPath(versionDir) {
-  return pathResolve(versionDir, ".codex-plugin", "plugin.json");
-}
-function codexPluginMcpPath(versionDir) {
-  return pathResolve(versionDir, ".mcp.json");
-}
-function codexPluginSkillsDir(versionDir) {
-  return pathResolve(versionDir, "skills");
-}
-function codexConfigBackupPath(home, now) {
-  const ts = formatBackupTimestamp(now);
-  return `${codexConfigTomlPath(home)}.bak.${ts}`;
-}
-function formatBackupTimestamp(date) {
-  const pad = (n) => String(n).padStart(2, "0");
-  const yyyy = date.getUTCFullYear();
-  const mm = pad(date.getUTCMonth() + 1);
-  const dd = pad(date.getUTCDate());
-  const hh = pad(date.getUTCHours());
-  const mi = pad(date.getUTCMinutes());
-  const ss = pad(date.getUTCSeconds());
-  return `${yyyy}${mm}${dd}-${hh}${mi}${ss}`;
-}
-function pluginSectionKey(ref) {
-  return `${ref.name}@${ref.marketplace}`;
-}
-
-// src/installers/codex/toml.ts
-import { randomUUID } from "crypto";
-import { constants as fsConstants } from "fs";
-import {
-  access,
-  copyFile,
-  mkdir as mkdir2,
-  readFile as readFile2,
-  rename,
-  rm,
-  stat,
-  writeFile as writeFile2
-} from "fs/promises";
-import { dirname as dirname2 } from "path";
-import tomlModule from "@iarna/toml";
-var { parse: tomlParse, stringify: tomlStringify } = tomlModule;
-var CodexConfigTomlError = class extends Error {
+// src/installers/codex/installer.ts
+var CODEX_UNSUPPORTED = ["rules", "hooks"];
+var CodexInstallError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "CodexConfigTomlError";
-  }
-};
-var CodexConfigTomlCorruptError = class extends CodexConfigTomlError {
-  constructor(filePath, cause) {
-    super(
-      `Codex config.toml \u89E3\u6790\u5931\u8D25\uFF08${filePath}\uFF09\u3002\u8BF7\u5907\u4EFD\u540E\u624B\u5DE5\u4FEE\u590D\u3002\u539F\u56E0\uFF1A${String(
-        cause?.message ?? cause
-      )}`
-    );
-    this.filePath = filePath;
-    this.cause = cause;
-    this.name = "CodexConfigTomlCorruptError";
-  }
-};
-var CodexConfigTomlConflictError = class extends CodexConfigTomlError {
-  constructor(filePath) {
-    super(
-      `Codex config.toml \u5E76\u53D1\u5199\u51B2\u7A81\uFF1A\u8BFB\u53D6\u548C\u5199\u5165\u4E4B\u95F4 ${filePath} \u88AB\u5176\u4ED6\u8FDB\u7A0B\u4FEE\u6539\u3002\u8BF7\u91CD\u8BD5\u3002`
-    );
-    this.filePath = filePath;
-    this.name = "CodexConfigTomlConflictError";
+    this.name = "CodexInstallError";
   }
 };
-async function readCodexConfig(filePath) {
-  if (!await pathExists2(filePath)) {
-    return { data: {}, mtimeMs: null };
-  }
-  const stats = await stat(filePath);
-  const raw = await readFile2(filePath, "utf8");
-  try {
-    const parsed = tomlParse(raw);
-    return { data: parsed, mtimeMs: stats.mtimeMs };
-  } catch (err) {
-    throw new CodexConfigTomlCorruptError(filePath, err);
+var CodexInstaller = class {
+  target = "codex";
+  home;
+  rushAiBinaryResolver;
+  now;
+  marketplaceSource;
+  constructor(opts = {}) {
+    this.home = opts.home ?? homedir3();
+    this.rushAiBinaryResolver = opts.rushAiBinaryResolver ?? defaultRushAiBinaryResolver;
+    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
+    this.marketplaceSource = opts.marketplaceSource;
   }
-}
-async function backupCodexConfig(filePath, backupPath) {
-  if (!await pathExists2(filePath)) {
-    return null;
+  // -------------------------------------------------------------------------
+  // detect / isInstalled / list
+  // -------------------------------------------------------------------------
+  async detect() {
+    return isDir(codexHomeDir(this.home));
   }
-  let finalBackup = backupPath;
-  if (await pathExists2(finalBackup)) {
-    finalBackup = `${backupPath}.${randomUUID().slice(0, 8)}`;
+  async isInstalled(ref) {
+    const cfgPath = codexConfigTomlPath(this.home);
+    if (!await pathExists2(cfgPath)) return false;
+    const { data } = await readCodexConfig(cfgPath);
+    const plugins = data.plugins;
+    if (!plugins || typeof plugins !== "object") return false;
+    const key = pluginSectionKey(ref);
+    const entry = plugins[key];
+    if (!entry || typeof entry !== "object") return false;
+    return entry.enabled === true;
   }
-  await copyFile(filePath, finalBackup);
-  return finalBackup;
-}
-async function writeCodexConfig(filePath, data, expectedMtimeMs) {
-  await assertNoMtimeDrift(filePath, expectedMtimeMs);
-  const serialized = tomlStringify(data);
-  await atomicWrite(filePath, serialized);
-  const afterStats = await stat(filePath);
-  return { mtimeMs: afterStats.mtimeMs };
-}
-async function restoreCodexConfigFromBackup(filePath, backupPath) {
-  if (!backupPath || !await pathExists2(backupPath)) {
-    if (await pathExists2(filePath)) {
-      await rm(filePath, { force: true });
+  async list() {
+    const cfgPath = codexConfigTomlPath(this.home);
+    if (!await pathExists2(cfgPath)) return [];
+    const { data } = await readCodexConfig(cfgPath);
+    const plugins = data.plugins;
+    if (!plugins || typeof plugins !== "object") return [];
+    const results = [];
+    for (const [key, raw] of Object.entries(plugins)) {
+      if (!raw || typeof raw !== "object") continue;
+      const entry = raw;
+      if (entry.enabled !== true) continue;
+      const ref = parsePluginKey(key);
+      if (!ref) continue;
+      const detected = await detectInstalledVersion(this.home, ref);
+      results.push({
+        ref,
+        version: detected?.version ?? "unknown",
+        installedAt: detected?.installedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        targets: ["codex"]
+      });
     }
-    return;
-  }
-  const raw = await readFile2(backupPath, "utf8");
-  await atomicWrite(filePath, raw);
-  await rm(backupPath, { force: true }).catch(() => {
-  });
-}
-function setMarketplaceSection(config, name, entry) {
-  const mkts = ensureObjectSection(config, "marketplaces");
-  mkts[name] = { ...entry };
-}
-function removeMarketplaceSection(config, name) {
-  const mkts = config.marketplaces;
-  if (!mkts || typeof mkts !== "object") return;
-  delete mkts[name];
-  if (Object.keys(mkts).length === 0) {
-    delete config.marketplaces;
-  }
-}
-function setPluginEntry(config, key, entry) {
-  const plugins = ensureObjectSection(config, "plugins");
-  plugins[key] = { ...entry };
-}
-function removePluginEntry(config, key) {
-  const plugins = config.plugins;
-  if (!plugins || typeof plugins !== "object") return;
-  delete plugins[key];
-  if (Object.keys(plugins).length === 0) {
-    delete config.plugins;
-  }
-}
-var MCP_OWNER_MARKER_KEY = "_rush_ai_owner";
-function setMcpServerSection(config, serverName, ownerKey, entry) {
-  const servers = ensureObjectSection(config, "mcp_servers");
-  servers[serverName] = { ...entry, [MCP_OWNER_MARKER_KEY]: ownerKey };
-}
-function removeMcpServerSection(config, serverName, expectedOwner) {
-  const servers = config.mcp_servers;
-  if (!servers || typeof servers !== "object") return "absent";
-  const entry = servers[serverName];
-  if (!entry || typeof entry !== "object") return "absent";
-  const owner = entry[MCP_OWNER_MARKER_KEY];
-  if (owner !== expectedOwner) return "foreign";
-  delete servers[serverName];
-  if (Object.keys(servers).length === 0) {
-    delete config.mcp_servers;
-  }
-  return "removed";
-}
-function getMcpServerOwner(config, serverName) {
-  const servers = config.mcp_servers;
-  if (!servers || typeof servers !== "object") return null;
-  const entry = servers[serverName];
-  if (!entry || typeof entry !== "object") return null;
-  const owner = entry[MCP_OWNER_MARKER_KEY];
-  return typeof owner === "string" ? owner : void 0;
-}
-async function pathExists2(p) {
-  try {
-    await access(p, fsConstants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function atomicWrite(filePath, content) {
-  await mkdir2(dirname2(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID()}.tmp`;
-  try {
-    await writeFile2(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename(tmp, filePath);
-  } catch (err) {
-    await rm(tmp, { force: true }).catch(() => {
+    results.sort((a, b) => {
+      const ka = `${a.ref.name}@${a.ref.marketplace}`;
+      const kb = `${b.ref.name}@${b.ref.marketplace}`;
+      return ka < kb ? -1 : ka > kb ? 1 : 0;
     });
-    throw err;
+    return results;
   }
-}
-async function assertNoMtimeDrift(filePath, expectedMtimeMs) {
-  if (expectedMtimeMs === null) {
-    if (await pathExists2(filePath)) {
-      throw new CodexConfigTomlConflictError(filePath);
+  // -------------------------------------------------------------------------
+  // install / uninstall
+  // -------------------------------------------------------------------------
+  async install(plugin, opts = {}) {
+    if (!await this.detect()) {
+      return {
+        target: "codex",
+        status: "skipped",
+        included: [],
+        skipped: [],
+        artifacts: { files: [], mcpKeys: [] }
+      };
     }
-    return;
-  }
-  const current = await stat(filePath).catch(() => null);
-  if (current === null) {
-    throw new CodexConfigTomlConflictError(filePath);
-  }
-  if (current.mtimeMs !== expectedMtimeMs) {
-    throw new CodexConfigTomlConflictError(filePath);
-  }
-}
-function ensureObjectSection(config, key) {
-  const existing = config[key];
-  if (existing === void 0) {
-    const fresh = {};
-    config[key] = fresh;
-    return fresh;
-  }
-  if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
-    throw new CodexConfigTomlError(
-      `config.toml \u9876\u5C42 '${key}' \u5DF2\u5B58\u5728\u4F46\u4E0D\u662F object\uFF08type=${Array.isArray(existing) ? "array" : typeof existing}\uFF09\u3002\u8BF7\u624B\u5DE5\u5907\u4EFD\u5E76\u6574\u7406\u8BE5\u5B57\u6BB5\u540E\u91CD\u8BD5\u3002`
-    );
-  }
-  return existing;
-}
-
-// src/installers/codex/mirror.ts
-function isSafePluginName(name) {
-  if (typeof name !== "string" || name.length === 0) return false;
-  if (name === "." || name === "..") return false;
-  if (name.startsWith(".")) return false;
-  if (name.includes("/") || name.includes("\\")) return false;
-  if (name.includes("..")) return false;
-  return /^[A-Za-z0-9_@][A-Za-z0-9._@-]*$/.test(name);
-}
-var DEFAULT_CATEGORY = "Engineering";
-var DEFAULT_CAPABILITIES = ["Read", "Write"];
-async function syncCodexMarketplaceMirror(home, resolved, opts = {}) {
-  const result = {
-    skipped: false,
-    added: [],
-    refreshed: [],
-    preservedFull: [],
-    removed: [],
-    warnings: []
-  };
-  if (!await isDir(codexHomeDir(home))) {
-    result.skipped = true;
-    return result;
-  }
-  const marketplaceDir = codexMarketplaceDir(home, resolved.name);
-  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
-  const contentLoader = opts.contentLoader ?? (async () => ({}));
-  const fallback = {
-    name: resolved.name,
-    interface: { displayName: resolved.name },
-    plugins: []
-  };
-  const existing = await readCodexMarketplaceCatalog(manifestPath, fallback);
-  const existingByName = new Map(existing.plugins.map((p) => [p.name, p]));
-  const remotePlugins = [];
-  const remoteNames = /* @__PURE__ */ new Set();
-  for (const entry of resolved.manifest.plugins) {
-    if (typeof entry?.name !== "string" || !isSafePluginName(entry.name)) {
-      const display = typeof entry?.name === "string" ? entry.name : "<unnamed>";
-      result.warnings.push(`skipped plugin with unsafe name: ${display}`);
-      output.warn(
-        `[codex] marketplace '${resolved.name}': skipped plugin with unsafe name: ${display}`
-      );
-      continue;
+    const pathGuardError = assertSafePathComponents(plugin.ref, plugin.version);
+    if (pathGuardError) {
+      return {
+        target: "codex",
+        status: "failed",
+        included: [],
+        skipped: [],
+        artifacts: { files: [], mcpKeys: [] },
+        errors: [pathGuardError]
+      };
     }
-    if (remoteNames.has(entry.name)) {
-      result.warnings.push(`duplicate plugin name in manifest: ${entry.name}`);
-      continue;
+    const ref = plugin.ref;
+    if (!opts.force && plugin.version !== "unknown" && await this.isInstalled(ref) && await isFullyInstalledMirror(this.home, ref)) {
+      const existingVersion = await detectInstalledVersion(this.home, ref);
+      if (existingVersion?.version === plugin.version) {
+        return {
+          target: "codex",
+          status: "ok",
+          included: computeIncludedCapabilities(plugin),
+          skipped: [...CODEX_UNSUPPORTED],
+          artifacts: { files: [], mcpKeys: [] },
+          notes: [`\u63D2\u4EF6\u5DF2\u88C5\uFF08version=${plugin.version}\uFF09\uFF0C\u8DF3\u8FC7\u91CD\u590D\u5B89\u88C5`]
+        };
+      }
     }
-    remotePlugins.push(entry);
-    remoteNames.add(entry.name);
-  }
-  const nextEntries = [];
-  for (const entry of remotePlugins) {
-    const pluginDir = codexMarketplacePluginDir(marketplaceDir, entry.name);
-    const fullState = await detectFullPluginDir(pluginDir);
-    if (fullState === "full") {
-      const prior = existingByName.get(entry.name);
-      const base = prior ?? buildStubCatalogEntry(entry);
-      const fullEntry = {
-        ...base,
-        policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" }
-      };
-      nextEntries.push(fullEntry);
-      result.preservedFull.push(entry.name);
-      continue;
+    if (opts.dryRun) {
+      return this.buildDryRunResult(plugin);
     }
-    let content = {};
+    const rollback = {
+      createdVersionDir: null,
+      createdMarketplacePluginDir: null,
+      backupPath: null,
+      preExistingConfig: null
+    };
     try {
-      content = await contentLoader(entry);
+      return await this.doInstall(plugin, rollback);
     } catch (err) {
-      result.warnings.push(
-        `contentLoader failed for '${entry.name}': ${err.message}`
-      );
-      output.warn(
-        `[codex] marketplace '${resolved.name}': contentLoader failed for '${entry.name}': ${err.message}`
-      );
-      content = {};
-    }
-    try {
-      await writePluginMaterials(pluginDir, entry, content, resolved.name);
-    } catch (err) {
-      result.warnings.push(
-        `failed to write stub for '${entry.name}': ${err.message}`
-      );
-      output.warn(
-        `[codex] marketplace '${resolved.name}': failed to write stub for '${entry.name}': ${err.message}`
-      );
-      continue;
-    }
-    nextEntries.push(buildStubCatalogEntry(entry, content));
-    if (existingByName.has(entry.name)) {
-      result.refreshed.push(entry.name);
-    } else {
-      result.added.push(entry.name);
-    }
-  }
-  for (const prior of existing.plugins) {
-    if (remoteNames.has(prior.name)) continue;
-    if (!isSafePluginName(prior.name)) {
-      result.warnings.push(
-        `dropped catalog entry with unsafe name: ${prior.name}`
-      );
-      output.warn(
-        `[codex] marketplace '${resolved.name}': dropped catalog entry with unsafe name: ${prior.name}`
-      );
-      result.removed.push(prior.name);
-      continue;
-    }
-    const pluginDir = codexMarketplacePluginDir(marketplaceDir, prior.name);
-    if (await detectFullPluginDir(pluginDir) === "full") {
-      nextEntries.push(prior);
-      output.warn(
-        `[codex] marketplace '${resolved.name}': installed plugin '${prior.name}' no longer in remote catalog; keeping entry. Run 'rush-ai plugin uninstall ${prior.name}@${resolved.name}' if intended.`
-      );
-      continue;
-    }
-    await rm2(pluginDir, { recursive: true, force: true }).catch(() => {
-    });
-    result.removed.push(prior.name);
-  }
-  nextEntries.sort((a, b) => a.name.localeCompare(b.name));
-  const nextCatalog = {
-    name: existing.name || resolved.name,
-    interface: existing.interface ?? fallback.interface,
-    plugins: nextEntries
-  };
-  await writeFileAtomic(
-    manifestPath,
-    `${JSON.stringify(nextCatalog, null, 2)}
-`
-  );
-  try {
-    await registerMarketplaceInCodexConfig({
-      home,
-      marketplaceName: resolved.name,
-      marketplaceDir,
-      now: opts.now ?? (() => /* @__PURE__ */ new Date())
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    result.warnings.push(
-      `failed to register [marketplaces.${resolved.name}] in config.toml: ${msg}`
-    );
-    output.warn(
-      `[codex] marketplace '${resolved.name}': failed to register in config.toml: ${msg}`
-    );
-  }
-  return result;
-}
-async function registerMarketplaceInCodexConfig(args) {
-  const cfgPath = codexConfigTomlPath(args.home);
-  await backupCodexConfig(
-    cfgPath,
-    codexConfigBackupPath(args.home, args.now())
-  );
-  const { data, mtimeMs } = await readCodexConfig(cfgPath);
-  setMarketplaceSection(data, args.marketplaceName, {
-    last_updated: args.now().toISOString(),
-    source_type: "local",
-    source: args.marketplaceDir
-  });
-  await writeCodexConfig(cfgPath, data, mtimeMs);
-}
-async function writeCodexMarketplacePluginMirror(input) {
-  const pluginParent = dirname3(input.pluginDir);
-  const pluginBase = basename2(input.pluginDir);
-  await mkdir3(pluginParent, { recursive: true });
-  const tmpPluginDir = await mkdtemp(
-    resolve3(pluginParent, `.${pluginBase}.tmp-`)
-  );
-  const backupPluginDir = await mkdtemp(
-    resolve3(pluginParent, `.${pluginBase}.bak-`)
-  );
-  let hadExistingPluginDir = false;
-  let swappedPluginDir = false;
-  try {
-    await rm2(tmpPluginDir, { recursive: true, force: true });
-    await rm2(backupPluginDir, { recursive: true, force: true }).catch(() => {
-    });
-    await cp(input.versionDir, tmpPluginDir, {
-      recursive: true,
-      dereference: false,
-      preserveTimestamps: true,
-      verbatimSymlinks: true
-    });
-    hadExistingPluginDir = await pathExists3(input.pluginDir);
-    if (hadExistingPluginDir) {
-      await rename2(input.pluginDir, backupPluginDir);
-    }
-    await rename2(tmpPluginDir, input.pluginDir);
-    swappedPluginDir = true;
-    await upsertCodexCatalogPluginFull(input.marketplaceDir, input.plugin);
-    if (hadExistingPluginDir) {
-      await rm2(backupPluginDir, { recursive: true, force: true });
-    }
-  } catch (err) {
-    await rm2(tmpPluginDir, { recursive: true, force: true }).catch(() => {
-    });
-    let restoredBackup = false;
-    if (hadExistingPluginDir && await pathExists3(backupPluginDir)) {
-      let displacedPluginDir = null;
-      try {
-        if (await pathExists3(input.pluginDir)) {
-          displacedPluginDir = await mkdtemp(
-            resolve3(pluginParent, `.${pluginBase}.failed-`)
-          );
-          await rm2(displacedPluginDir, { recursive: true, force: true });
-          await rename2(input.pluginDir, displacedPluginDir);
-        }
-        await rename2(backupPluginDir, input.pluginDir);
-        restoredBackup = true;
-        if (displacedPluginDir) {
-          await rm2(displacedPluginDir, { recursive: true, force: true }).catch(
-            () => {
-            }
-          );
-        }
-      } catch {
-        if (displacedPluginDir && !await pathExists3(input.pluginDir) && await pathExists3(displacedPluginDir)) {
-          await rename2(displacedPluginDir, input.pluginDir).catch(() => {
-          });
-        }
-      }
-    } else if (swappedPluginDir) {
-      await rm2(input.pluginDir, { recursive: true, force: true }).catch(
-        () => {
-        }
-      );
-    }
-    if (restoredBackup || !hadExistingPluginDir) {
-      await rm2(backupPluginDir, { recursive: true, force: true }).catch(
-        () => {
-        }
-      );
-    }
-    throw err;
-  }
-}
-async function upsertCodexCatalogPluginFull(marketplaceDir, plugin) {
-  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
-  const fallback = {
-    name: plugin.ref.marketplace,
-    interface: { displayName: plugin.ref.marketplace },
-    plugins: []
-  };
-  const catalog = await readCodexMarketplaceCatalog(manifestPath, fallback);
-  const nextEntry = {
-    name: plugin.ref.name,
-    source: { source: "local", path: `./plugins/${plugin.ref.name}` },
-    policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
-    category: buildInterfaceCategory(plugin.manifest)
-  };
-  if (plugin.manifest.description !== void 0) {
-    nextEntry.description = plugin.manifest.description;
-  }
-  if (typeof plugin.manifest.version === "string") {
-    nextEntry.version = plugin.manifest.version;
-  }
-  const next = [
-    ...catalog.plugins.filter((entry) => entry.name !== plugin.ref.name),
-    nextEntry
-  ].sort((a, b) => a.name.localeCompare(b.name));
-  await writeFileAtomic(
-    manifestPath,
-    `${JSON.stringify({ ...catalog, plugins: next }, null, 2)}
-`
-  );
-}
-async function downgradeCodexCatalogEntryToStub(marketplaceDir, pluginName) {
-  const manifestPath = codexMarketplaceManifestPath(marketplaceDir);
-  const pluginDir = codexMarketplacePluginDir(marketplaceDir, pluginName);
-  await rm2(pluginDir, { recursive: true, force: true }).catch(() => {
-  });
-  if (!await pathExists3(manifestPath)) return;
-  try {
-    const fallback = {
-      name: "",
-      interface: {},
-      plugins: []
-    };
-    const catalog = await readCodexMarketplaceCatalog(manifestPath, fallback);
-    const next = catalog.plugins.map((entry) => {
-      if (entry.name !== pluginName) return entry;
-      return {
-        ...entry,
-        policy: {
-          installation: "NOT_AVAILABLE",
-          authentication: "ON_INSTALL"
-        }
-      };
-    });
-    await writeFileAtomic(
-      manifestPath,
-      `${JSON.stringify({ ...catalog, plugins: next }, null, 2)}
-`
-    );
-  } catch {
-  }
-}
-async function readCodexMarketplaceCatalog(manifestPath, fallback) {
-  if (!await pathExists3(manifestPath)) return fallback;
-  try {
-    const parsed = JSON.parse(await readFile3(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(isCatalogPluginEntry) : fallback.plugins
-    };
-  } catch {
-    return fallback;
-  }
-}
-function isCatalogPluginEntry(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string";
-}
-function buildStubCatalogEntry(entry, content = {}) {
-  const description = pickNonEmptyString(entry.description) ?? pickNonEmptyString(content.manifest?.description);
-  const version = pickNonEmptyString(entry.version) ?? pickNonEmptyString(content.manifest?.version);
-  const m = content.manifest ?? void 0;
-  const ifaceIn = m?.interface ?? {};
-  const entryCategory = pickNonEmptyString(
-    entry.category
-  );
-  const category = pickNonEmptyString(ifaceIn.category) ?? normalizeCategory(entryCategory) ?? DEFAULT_CATEGORY;
-  const out = {
-    name: entry.name,
-    source: { source: "local", path: `./plugins/${entry.name}` },
-    // stub 入口 → 标记为 NOT_AVAILABLE，让 Codex UI 禁用"连接"按钮，
-    // 因为点击连接只会写一份没有 MCP key 的伪安装。真正安装走
-    // `npx rush-ai@latest plugin install <name>@<marketplace>`。
-    // 已装 full 路径在 upsertCodexCatalogPluginFull 中覆写为 AVAILABLE。
-    policy: { installation: "NOT_AVAILABLE", authentication: "ON_INSTALL" },
-    category
-  };
-  if (description !== void 0) out.description = description;
-  if (version !== void 0) out.version = version;
-  return out;
-}
-function buildPluginJson(entry, content, marketplaceName) {
-  const m = content.manifest ?? void 0;
-  const author = m?.author ?? (entry.author && typeof entry.author === "object" ? entry.author : void 0);
-  const homepage = pickNonEmptyString(m?.homepage) ?? pickNonEmptyString(entry.homepage);
-  const license = pickNonEmptyString(m?.license) ?? pickNonEmptyString(entry.license);
-  const keywords = Array.isArray(m?.keywords) && m.keywords.length > 0 ? m.keywords : Array.isArray(entry.keywords) && entry.keywords.length > 0 ? entry.keywords : void 0;
-  const entryCategory = pickNonEmptyString(
-    entry.category
-  );
-  const sourceUrl = extractSourceUrl(entry.source);
-  const description = pickNonEmptyString(m?.description) ?? pickNonEmptyString(entry.description) ?? entry.name;
-  const version = pickNonEmptyString(m?.version) ?? pickNonEmptyString(entry.version) ?? "0.0.0";
-  const ifaceIn = m?.interface ?? {};
-  const developerName = pickNonEmptyString(ifaceIn.developerName) ?? pickNonEmptyString(author?.name);
-  const websiteURL = pickNonEmptyString(ifaceIn.websiteURL) ?? sourceUrl ?? homepage;
-  const category = pickNonEmptyString(ifaceIn.category) ?? normalizeCategory(entryCategory) ?? DEFAULT_CATEGORY;
-  const capabilities = Array.isArray(ifaceIn.capabilities) && ifaceIn.capabilities.length > 0 ? [...ifaceIn.capabilities] : [...DEFAULT_CAPABILITIES];
-  const installCmd = `npx rush-ai@latest plugin install ${entry.name}@${marketplaceName} --target codex`;
-  const shortHintPrefix = "\u26A0 \u9700\u5728\u7EC8\u7AEF\u5B89\u88C5 \uFF5C ";
-  const authorShort = pickNonEmptyString(ifaceIn.shortDescription) ?? description;
-  const baseLongDescription = pickNonEmptyString(ifaceIn.longDescription) ?? pickNonEmptyString(ifaceIn.shortDescription) ?? description;
-  const extraLinks = [];
-  if (homepage !== void 0 && homepage !== websiteURL) {
-    extraLinks.push(`\u5B98\u7F51\uFF1A${homepage}`);
-  }
-  if (sourceUrl !== void 0 && sourceUrl !== websiteURL && sourceUrl !== homepage) {
-    extraLinks.push(`\u6E90\u4EE3\u7801\uFF1A${sourceUrl}`);
-  }
-  const extraLinksSection = extraLinks.length > 0 ? `
-
-${extraLinks.join("\n")}` : "";
-  const installSection = `\u2014\u2014\u2014
-\u26A0 Codex \u684C\u9762\u7AEF\u7684"\u8FDE\u63A5"\u6309\u94AE\u65E0\u6CD5\u5B8C\u6574\u5B89\u88C5\u672C\u63D2\u4EF6
-\u8BF7\u5728\u7EC8\u7AEF\u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u5B8C\u6210\u5B89\u88C5\uFF1A
-${installCmd}`;
-  const longDescription = `${baseLongDescription}${extraLinksSection}
-
-${installSection}`;
-  const defaultPrompt = Array.isArray(ifaceIn.defaultPrompt) ? [...ifaceIn.defaultPrompt] : [];
-  if (defaultPrompt.length === 0) {
-    defaultPrompt.push(installCmd);
-  }
-  const ifaceOut = {
-    displayName: pickNonEmptyString(ifaceIn.displayName) ?? entry.name,
-    shortDescription: `${shortHintPrefix}${authorShort}`,
-    longDescription,
-    category,
-    capabilities,
-    defaultPrompt
-  };
-  if (developerName !== void 0) ifaceOut.developerName = developerName;
-  if (websiteURL !== void 0) ifaceOut.websiteURL = websiteURL;
-  if (pickNonEmptyString(ifaceIn.privacyPolicyURL) !== void 0)
-    ifaceOut.privacyPolicyURL = ifaceIn.privacyPolicyURL;
-  if (pickNonEmptyString(ifaceIn.termsOfServiceURL) !== void 0)
-    ifaceOut.termsOfServiceURL = ifaceIn.termsOfServiceURL;
-  if (pickNonEmptyString(ifaceIn.brandColor) !== void 0)
-    ifaceOut.brandColor = ifaceIn.brandColor;
-  if (pickNonEmptyString(ifaceIn.composerIcon) !== void 0)
-    ifaceOut.composerIcon = ifaceIn.composerIcon;
-  if (pickNonEmptyString(ifaceIn.logo) !== void 0)
-    ifaceOut.logo = ifaceIn.logo;
-  if (Array.isArray(ifaceIn.screenshots) && ifaceIn.screenshots.length > 0)
-    ifaceOut.screenshots = [...ifaceIn.screenshots];
-  const out = {
-    // marker：让 detectFullPluginDir 可靠区分 sync vs install 写出的目录。
-    // Codex 不知道这个字段，会被忽略；marker 必须是合法 JSON 字段名才能被 plugin.json 接受。
-    [STUB_MARKER_KEY]: STUB_MARKER_VALUE,
-    name: entry.name,
-    version,
-    description,
-    skills: "./skills/",
-    interface: ifaceOut
-  };
-  if (author && typeof author === "object") {
-    out.author = { ...author };
-  }
-  if (homepage !== void 0) {
-    out.homepage = homepage;
-  }
-  if (sourceUrl !== void 0) {
-    out.repository = sourceUrl;
-  }
-  if (license !== void 0) {
-    out.license = license;
-  }
-  if (keywords !== void 0) {
-    out.keywords = [...keywords];
-  }
-  if (hasMcpServers(content)) {
-    out.mcpServers = "./.mcp.json";
-  }
-  return out;
-}
-function extractSourceUrl(source) {
-  if (!source || typeof source === "string") return void 0;
-  const obj = source;
-  const url = obj.url;
-  if (typeof url !== "string" || url.length === 0) return void 0;
-  if (!/^https?:\/\//i.test(url)) return void 0;
-  return url.replace(/\.git$/, "");
-}
-function normalizeCategory(raw) {
-  if (raw === void 0) return void 0;
-  const lower = raw.toLowerCase().trim();
-  const map = {
-    development: "Engineering",
-    data: "Engineering",
-    devops: "Engineering",
-    design: "Design",
-    productivity: "Productivity",
-    security: "Security",
-    research: "Research",
-    automation: "Productivity",
-    integration: "Engineering"
-  };
-  if (lower in map) return map[lower];
-  return lower.charAt(0).toUpperCase() + lower.slice(1);
-}
-async function writePluginMaterials(pluginDir, entry, content, marketplaceName) {
-  const manifestPath = codexPluginManifestPath(pluginDir);
-  await mkdir3(dirname3(manifestPath), { recursive: true });
-  await rm2(codexPluginMcpPath(pluginDir), { force: true }).catch(() => {
-  });
-  await rm2(codexPluginSkillsDir(pluginDir), {
-    recursive: true,
-    force: true
-  }).catch(() => {
-  });
-  const pluginJson = buildPluginJson(entry, content, marketplaceName);
-  await writeFileAtomic(
-    manifestPath,
-    `${JSON.stringify(pluginJson, null, 2)}
-`
-  );
-  if (hasMcpServers(content)) {
-    const mcpPath = codexPluginMcpPath(pluginDir);
-    await writeFileAtomic(
-      mcpPath,
-      `${JSON.stringify({ mcpServers: content.mcpServers }, null, 2)}
-`
-    );
-  }
-  if (content.skillsSourceDir && await isDir(content.skillsSourceDir)) {
-    const skillsDir = codexPluginSkillsDir(pluginDir);
-    await mkdir3(skillsDir, { recursive: true });
-    await cp(content.skillsSourceDir, skillsDir, {
-      recursive: true,
-      dereference: false,
-      preserveTimestamps: true,
-      verbatimSymlinks: true
-    });
-  } else if (Array.isArray(content.skillsPlaceholders) && content.skillsPlaceholders.length > 0) {
-    const installCmd = pickNonEmptyString(content.installCommand) ?? `npx rush-ai@latest plugin install ${entry.name}@${marketplaceName} --target codex`;
-    const pluginWebUrl = pickNonEmptyString(content.pluginWebUrl);
-    const skillsDir = codexPluginSkillsDir(pluginDir);
-    const usedDirs = /* @__PURE__ */ new Set();
-    for (const skill of content.skillsPlaceholders) {
-      if (!isSafeSkillName(skill.name)) continue;
-      const dirName = uniqueDirName(slugifySkillName(skill.name), usedDirs);
-      usedDirs.add(dirName);
-      const skillDir = resolve3(skillsDir, dirName);
-      await mkdir3(skillDir, { recursive: true });
-      const rawSkillMd = pickNonEmptyString(skill.rawSkillMd);
-      if (rawSkillMd !== void 0) {
-        const rewritten = rewriteSkillMdName(rawSkillMd, dirName);
-        await writeFileAtomic(resolve3(skillDir, "SKILL.md"), rewritten);
-        continue;
-      }
-      const desc = pickNonEmptyString(skill.description) ?? `Skill ${skill.name}`;
-      const fullDesc = skill.name === dirName ? desc : `${skill.name} \u2014 ${desc}`;
-      const skillUrl = pickNonEmptyString(skill.url);
-      const body = buildSkillPlaceholderBody({
-        name: skill.name,
-        description: fullDesc,
-        skillUrl,
-        pluginWebUrl,
-        installCmd
-      });
-      const md = `---
-name: ${jsonQuote(dirName)}
-description: ${jsonQuote(fullDesc)}
----
-
-${body}
-`;
-      await writeFileAtomic(resolve3(skillDir, "SKILL.md"), md);
-    }
-  }
-}
-function rewriteSkillMdName(raw, dirName) {
-  const text = raw.replace(/\r\n/g, "\n");
-  if (!text.startsWith("---\n")) {
-    return `---
-name: ${jsonQuote(dirName)}
-description: ${jsonQuote(dirName)}
----
-
-` + text;
-  }
-  const lines = text.split("\n");
-  let closeIdx = -1;
-  for (let i = 1; i < lines.length; i++) {
-    if (lines[i] === "---") {
-      closeIdx = i;
-      break;
-    }
-  }
-  if (closeIdx === -1) {
-    return `---
-name: ${jsonQuote(dirName)}
-description: ${jsonQuote(dirName)}
----
-
-` + text;
-  }
-  let foundName = false;
-  for (let i = 1; i < closeIdx; i++) {
-    const line = lines[i] ?? "";
-    if (/^name\s*:/.test(line)) {
-      lines[i] = `name: ${jsonQuote(dirName)}`;
-      foundName = true;
-      break;
-    }
-  }
-  if (!foundName) {
-    lines.splice(1, 0, `name: ${jsonQuote(dirName)}`);
-  }
-  return lines.join("\n");
-}
-function buildSkillPlaceholderBody(input) {
-  const lines = [];
-  lines.push(`# ${input.name}`);
-  lines.push("");
-  lines.push(input.description);
-  lines.push("");
-  lines.push(
-    "> \u8FD9\u662F rush-ai marketplace \u540C\u6B65\u51FA\u7684\u5360\u4F4D skill \u2014\u2014 skill \u5B8C\u6574\u5185\u5BB9\uFF08trigger / \u64CD\u4F5C\u6B65\u9AA4 / \u63D0\u793A\u8BCD\uFF09\u5C1A\u672A\u4E0B\u8F7D\u3002"
-  );
-  lines.push(">");
-  lines.push("> \u5728\u7EC8\u7AEF\u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u4EE5\u5B8C\u6574\u5B89\u88C5\uFF1A");
-  lines.push(">");
-  lines.push("> ```bash");
-  lines.push(`> ${input.installCmd}`);
-  lines.push("> ```");
-  if (input.skillUrl !== void 0) {
-    lines.push(">");
-    lines.push(`> \u4E5F\u53EF\u5728 web \u7AD9\u70B9\u67E5\u770B\uFF1A[${input.name}](${input.skillUrl})`);
-  }
-  if (input.pluginWebUrl !== void 0) {
-    lines.push(">");
-    lines.push(`> \u6D4F\u89C8\u6240\u5C5E plugin\uFF1A${input.pluginWebUrl}`);
-  }
-  return lines.join("\n");
-}
-function jsonQuote(s) {
-  return JSON.stringify(s);
-}
-function slugifySkillName(name) {
-  return name.replace(/^@/, "").replace(/[\\/.]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "") || "skill";
-}
-function uniqueDirName(base, used) {
-  if (!used.has(base)) return base;
-  let i = 2;
-  while (used.has(`${base}-${i}`)) i += 1;
-  return `${base}-${i}`;
-}
-function isSafeSkillName(name) {
-  if (typeof name !== "string" || name.length === 0) return false;
-  if (name === "." || name === "..") return false;
-  if (name.startsWith(".")) return false;
-  if (name.includes("\\")) return false;
-  if (name.includes("..")) return false;
-  const slashCount = (name.match(/\//g) ?? []).length;
-  if (slashCount > 1) return false;
-  if (slashCount === 1 && !name.startsWith("@")) return false;
-  return /^@?[A-Za-z0-9_][A-Za-z0-9._@/-]*$/.test(name);
-}
-function hasMcpServers(content) {
-  return !!content.mcpServers && typeof content.mcpServers === "object" && Object.keys(content.mcpServers).length > 0;
-}
-function pickNonEmptyString(value) {
-  if (typeof value === "string" && value.length > 0) return value;
-  return void 0;
-}
-var STUB_MARKER_KEY = "x-rush-mirror";
-var STUB_MARKER_VALUE = "stub";
-async function detectFullPluginDir(pluginDir) {
-  if (!await isDir(pluginDir)) return "stub";
-  const manifestPath = codexPluginManifestPath(pluginDir);
-  if (await pathExists3(manifestPath)) {
-    try {
-      const raw = await readFile3(manifestPath, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed[STUB_MARKER_KEY] === STUB_MARKER_VALUE) {
-        return "stub";
-      }
-    } catch {
-    }
-  }
-  if (await dirHasEntries(codexPluginSkillsDir(pluginDir))) {
-    return "full";
-  }
-  const mcpPath = codexPluginMcpPath(pluginDir);
-  if (await pathExists3(mcpPath)) {
-    try {
-      const raw = await readFile3(mcpPath, "utf8");
-      if (!/\$\{[^}]+\}/.test(raw)) {
-        return "full";
-      }
-    } catch {
-    }
-  }
-  return "stub";
-}
-async function dirHasEntries(dir) {
-  if (!await isDir(dir)) return false;
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return false;
-  }
-  return entries.length > 0;
-}
-function buildInterfaceCategory(manifest) {
-  return manifest.interface?.category ?? DEFAULT_CATEGORY;
-}
-async function writeFileAtomic(filePath, content) {
-  await mkdir3(dirname3(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID2()}.tmp`;
-  try {
-    await writeFile3(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename2(tmp, filePath);
-  } catch (err) {
-    await rm2(tmp, { force: true }).catch(() => {
-    });
-    throw err;
-  }
-}
-async function pathExists3(p) {
-  try {
-    await access2(p, fsConstants2.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isDir(p) {
-  try {
-    const s = await stat2(p);
-    return s.isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-// src/installers/codex/installer.ts
-var CODEX_UNSUPPORTED = ["rules", "hooks"];
-var CodexInstallError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CodexInstallError";
-  }
-};
-var CodexInstaller = class {
-  target = "codex";
-  home;
-  rushAiBinaryResolver;
-  now;
-  marketplaceSource;
-  constructor(opts = {}) {
-    this.home = opts.home ?? homedir3();
-    this.rushAiBinaryResolver = opts.rushAiBinaryResolver ?? defaultRushAiBinaryResolver;
-    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
-    this.marketplaceSource = opts.marketplaceSource;
-  }
-  // -------------------------------------------------------------------------
-  // detect / isInstalled / list
-  // -------------------------------------------------------------------------
-  async detect() {
-    return isDir2(codexHomeDir(this.home));
-  }
-  async isInstalled(ref) {
-    const cfgPath = codexConfigTomlPath(this.home);
-    if (!await pathExists4(cfgPath)) return false;
-    const { data } = await readCodexConfig(cfgPath);
-    const plugins = data.plugins;
-    if (!plugins || typeof plugins !== "object") return false;
-    const key = pluginSectionKey(ref);
-    const entry = plugins[key];
-    if (!entry || typeof entry !== "object") return false;
-    return entry.enabled === true;
-  }
-  async list() {
-    const cfgPath = codexConfigTomlPath(this.home);
-    if (!await pathExists4(cfgPath)) return [];
-    const { data } = await readCodexConfig(cfgPath);
-    const plugins = data.plugins;
-    if (!plugins || typeof plugins !== "object") return [];
-    const results = [];
-    for (const [key, raw] of Object.entries(plugins)) {
-      if (!raw || typeof raw !== "object") continue;
-      const entry = raw;
-      if (entry.enabled !== true) continue;
-      const ref = parsePluginKey(key);
-      if (!ref) continue;
-      const detected = await detectInstalledVersion(this.home, ref);
-      results.push({
-        ref,
-        version: detected?.version ?? "unknown",
-        installedAt: detected?.installedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        targets: ["codex"]
-      });
-    }
-    results.sort((a, b) => {
-      const ka = `${a.ref.name}@${a.ref.marketplace}`;
-      const kb = `${b.ref.name}@${b.ref.marketplace}`;
-      return ka < kb ? -1 : ka > kb ? 1 : 0;
-    });
-    return results;
-  }
-  // -------------------------------------------------------------------------
-  // install / uninstall
-  // -------------------------------------------------------------------------
-  async install(plugin, opts = {}) {
-    if (!await this.detect()) {
-      return {
-        target: "codex",
-        status: "skipped",
-        included: [],
-        skipped: [],
-        artifacts: { files: [], mcpKeys: [] }
-      };
-    }
-    const pathGuardError = assertSafePathComponents(plugin.ref, plugin.version);
-    if (pathGuardError) {
-      return {
-        target: "codex",
-        status: "failed",
-        included: [],
-        skipped: [],
-        artifacts: { files: [], mcpKeys: [] },
-        errors: [pathGuardError]
-      };
-    }
-    const ref = plugin.ref;
-    if (!opts.force && plugin.version !== "unknown" && await this.isInstalled(ref) && await isFullyInstalledMirror(this.home, ref)) {
-      const existingVersion = await detectInstalledVersion(this.home, ref);
-      if (existingVersion?.version === plugin.version) {
-        return {
-          target: "codex",
-          status: "ok",
-          included: computeIncludedCapabilities(plugin),
-          skipped: [...CODEX_UNSUPPORTED],
-          artifacts: { files: [], mcpKeys: [] },
-          notes: [`\u63D2\u4EF6\u5DF2\u88C5\uFF08version=${plugin.version}\uFF09\uFF0C\u8DF3\u8FC7\u91CD\u590D\u5B89\u88C5`]
-        };
-      }
-    }
-    if (opts.dryRun) {
-      return this.buildDryRunResult(plugin);
-    }
-    const rollback = {
-      createdVersionDir: null,
-      createdMarketplacePluginDir: null,
-      backupPath: null,
-      preExistingConfig: null
-    };
-    try {
-      return await this.doInstall(plugin, rollback);
-    } catch (err) {
-      await rollbackInstall(this.home, rollback);
-      if (isExpectedInstallError(err)) {
-        const message = err.message;
-        return {
-          target: "codex",
-          status: "failed",
-          included: [],
-          skipped: [],
-          artifacts: { files: [], mcpKeys: [] },
-          errors: [message],
-          notes: rollback.backupPath ? [`\u5DF2\u4ECE\u5907\u4EFD\u6062\u590D config.toml\uFF08${rollback.backupPath} \u5DF2\u5220\u9664\uFF09`] : void 0
-        };
-      }
-      throw err;
+      await rollbackInstall(this.home, rollback);
+      if (isExpectedInstallError(err)) {
+        const message = err.message;
+        return {
+          target: "codex",
+          status: "failed",
+          included: [],
+          skipped: [],
+          artifacts: { files: [], mcpKeys: [] },
+          errors: [message],
+          notes: rollback.backupPath ? [`\u5DF2\u4ECE\u5907\u4EFD\u6062\u590D config.toml\uFF08${rollback.backupPath} \u5DF2\u5220\u9664\uFF09`] : void 0
+        };
+      }
+      throw err;
     }
   }
   async uninstall(ref, opts = {}) {
@@ -3595,7 +2681,7 @@ var CodexInstaller = class {
       };
     }
     const cfgPath = codexConfigTomlPath(this.home);
-    if (!await pathExists4(cfgPath)) {
+    if (!await pathExists2(cfgPath)) {
       return {
         target: "codex",
         status: "ok",
@@ -3687,11 +2773,11 @@ var CodexInstaller = class {
       ref.name
     );
     const cfgPath = codexConfigTomlPath(this.home);
-    const preExisted = await pathExists4(versionDir);
+    const preExisted = await pathExists2(versionDir);
     if (preExisted) {
-      await rm3(versionDir, { recursive: true, force: true });
+      await rm(versionDir, { recursive: true, force: true });
     }
-    await mkdir4(versionDir, { recursive: true });
+    await mkdir2(versionDir, { recursive: true });
     rollback.createdVersionDir = versionDir;
     const dstSkills = codexPluginSkillsDir(versionDir);
     const writtenFiles = [versionDir];
@@ -3729,7 +2815,7 @@ var CodexInstaller = class {
         );
         if (mcpContent) {
           const mcpPath = codexPluginMcpPath(versionDir);
-          await writeFileAtomic2(mcpPath, serializeMcpJson(mcpContent));
+          await writeFileAtomic(mcpPath, serializeMcpJson(mcpContent));
           writtenFiles.push(mcpPath);
           mcpJsonRef = "./.mcp.json";
           mcpKeys = listMcpKeys(mcpContent);
@@ -3739,7 +2825,7 @@ var CodexInstaller = class {
     }
     const pluginJsonObj = buildCodexPluginJson(plugin.manifest, mcpJsonRef);
     const pluginJsonPath = codexPluginManifestPath(versionDir);
-    await writeFileAtomic2(
+    await writeFileAtomic(
       pluginJsonPath,
       `${JSON.stringify(pluginJsonObj, null, 2)}
 `
@@ -3857,12 +2943,12 @@ var CodexInstaller = class {
     const srcMcp = plugin.manifest.mcpServers;
     if (srcMcp !== void 0 && srcMcp !== null) {
       if (typeof srcMcp === "string") {
-        const destPath = resolve4(versionDir, srcMcp);
+        const destPath = resolve3(versionDir, srcMcp);
         files.push(destPath);
-        const srcPath = resolve4(plugin.sourceDir, srcMcp);
-        const rel = pathRelative(resolve4(plugin.sourceDir), srcPath);
+        const srcPath = resolve3(plugin.sourceDir, srcMcp);
+        const rel = pathRelative(resolve3(plugin.sourceDir), srcPath);
         const traversal = rel === ".." || rel.startsWith("..") || rel.startsWith("/");
-        const exists = await pathExists4(srcPath);
+        const exists = await pathExists2(srcPath);
         if (traversal || !exists) {
           dryRunStatus = "failed";
           dryRunErrors.push(
@@ -3870,7 +2956,7 @@ var CodexInstaller = class {
           );
         } else {
           try {
-            const raw = await readFile4(srcPath, "utf8");
+            const raw = await readFile2(srcPath, "utf8");
             const parsed = JSON.parse(raw);
             if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
               mcpKeys = Object.keys(parsed.mcpServers).sort();
@@ -3956,18 +3042,18 @@ async function rollbackInstall(home, rollback) {
       }
     );
   } else if (rollback.preExistingConfig === false) {
-    await rm3(cfgPath, { force: true }).catch(() => {
+    await rm(cfgPath, { force: true }).catch(() => {
     });
   }
   if (rollback.createdVersionDir) {
-    await rm3(rollback.createdVersionDir, {
+    await rm(rollback.createdVersionDir, {
       recursive: true,
       force: true
     }).catch(() => {
     });
   }
   if (rollback.createdMarketplacePluginDir) {
-    await rm3(rollback.createdMarketplacePluginDir, {
+    await rm(rollback.createdMarketplacePluginDir, {
       recursive: true,
       force: true
     }).catch(() => {
@@ -4005,16 +3091,16 @@ function assertSafePathComponents(ref, version) {
 }
 async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
   if (typeof relativeRef !== "string" || relativeRef.length === 0) return null;
-  const srcPath = resolve4(sourceDir, relativeRef);
-  const rel = pathRelative(resolve4(sourceDir), srcPath);
+  const srcPath = resolve3(sourceDir, relativeRef);
+  const rel = pathRelative(resolve3(sourceDir), srcPath);
   if (rel === ".." || rel.startsWith("..") || rel.startsWith("/")) {
     return null;
   }
-  if (!await pathExists4(srcPath)) return null;
-  const destPath = resolve4(versionDir, relativeRef);
-  await mkdir4(dirname4(destPath), { recursive: true });
-  const raw = await readFile4(srcPath, "utf8");
-  await writeFileAtomic2(destPath, raw);
+  if (!await pathExists2(srcPath)) return null;
+  const destPath = resolve3(versionDir, relativeRef);
+  await mkdir2(dirname2(destPath), { recursive: true });
+  const raw = await readFile2(srcPath, "utf8");
+  await writeFileAtomic(destPath, raw);
   let mcpKeys = [];
   let mcpServers = {};
   try {
@@ -4036,7 +3122,7 @@ async function planCodexSkills(plugin) {
   const usedNames = /* @__PURE__ */ new Set();
   const coveredAliases = /* @__PURE__ */ new Set();
   const commandFiles = await listMarkdownFiles(
-    resolve4(plugin.sourceDir, "commands"),
+    resolve3(plugin.sourceDir, "commands"),
     {
       recursive: false
     }
@@ -4046,19 +3132,19 @@ async function planCodexSkills(plugin) {
       commandFiles.map((file2) => markdownSkillAlias(plugin.manifest.name, file2))
     )
   );
-  const nativeSkillsDir = resolve4(plugin.sourceDir, "skills");
+  const nativeSkillsDir = resolve3(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: resolve4(nativeSkillsDir, name),
+        sourceDir: resolve3(nativeSkillsDir, name),
         skillName: name
       });
     }
   } else {
-    const dotSkillsDir = resolve4(plugin.sourceDir, ".skills");
+    const dotSkillsDir = resolve3(plugin.sourceDir, ".skills");
     const claudeSkills = await listMarkdownFiles(dotSkillsDir);
     const claudeAliases = /* @__PURE__ */ new Map();
     for (const file2 of claudeSkills) {
@@ -4097,7 +3183,7 @@ async function planCodexSkills(plugin) {
 async function materializeCodexSkills(plan, dstSkills) {
   for (const source of plan.sources) {
     if (source.kind === "copy-skill") {
-      await cp2(source.sourceDir, resolve4(dstSkills, source.skillName), {
+      await cp(source.sourceDir, resolve3(dstSkills, source.skillName), {
         recursive: true,
         dereference: false,
         preserveTimestamps: true,
@@ -4105,10 +3191,10 @@ async function materializeCodexSkills(plan, dstSkills) {
       });
       continue;
     }
-    const raw = await readFile4(source.sourceFile, "utf8");
+    const raw = await readFile2(source.sourceFile, "utf8");
     const normalized = normalizeSkillMarkdown(raw, source.skillName);
-    await writeFileAtomic2(
-      resolve4(dstSkills, source.skillName, "SKILL.md"),
+    await writeFileAtomic(
+      resolve3(dstSkills, source.skillName, "SKILL.md"),
       normalized
     );
   }
@@ -4184,35 +3270,35 @@ async function hasCodexSkillDir(skillsDir) {
   return (await listCodexSkillNames(skillsDir)).length > 0;
 }
 async function listCodexSkillNames(skillsDir) {
-  if (!await isDir2(skillsDir)) return [];
+  if (!await isDir(skillsDir)) return [];
   let entries;
   try {
-    entries = await readdir2(skillsDir, { withFileTypes: true });
+    entries = await readdir(skillsDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    if (await pathExists4(resolve4(skillsDir, entry.name, "SKILL.md"))) {
+    if (await pathExists2(resolve3(skillsDir, entry.name, "SKILL.md"))) {
       names.push(entry.name);
     }
   }
   return names.sort();
 }
 async function listMarkdownFiles(dir, opts = {}) {
-  if (!await isDir2(dir)) return [];
+  if (!await isDir(dir)) return [];
   const recursive = opts.recursive !== false;
   const out = [];
   async function walk2(current) {
     let entries;
     try {
-      entries = await readdir2(current, { withFileTypes: true });
+      entries = await readdir(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const abs = resolve4(current, entry.name);
+      const abs = resolve3(current, entry.name);
       if (entry.isDirectory()) {
         if (recursive) await walk2(abs);
         continue;
@@ -4237,10 +3323,10 @@ function uniqueSkillName(used, desired) {
   return candidate;
 }
 async function markdownSkillAlias(pluginName, filePath) {
-  const triggerAlias = extractTriggerAlias(await readFile4(filePath, "utf8"));
+  const triggerAlias = extractTriggerAlias(await readFile2(filePath, "utf8"));
   return skillAlias(
     pluginName,
-    triggerAlias ?? basename3(filePath, extname(filePath))
+    triggerAlias ?? basename2(filePath, extname(filePath))
   );
 }
 function markdownPathAlias(pluginName, baseDir, filePath) {
@@ -4266,30 +3352,30 @@ function slugify(value) {
   const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return slug.length > 0 ? slug : "skill";
 }
-async function writeFileAtomic2(filePath, content) {
-  await mkdir4(dirname4(filePath), { recursive: true });
+async function writeFileAtomic(filePath, content) {
+  await mkdir2(dirname2(filePath), { recursive: true });
   const tmp = `${filePath}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile4(tmp, content, { encoding: "utf8", flag: "w" });
-    const { rename: rename10 } = await import("fs/promises");
-    await rename10(tmp, filePath);
+    await writeFile2(tmp, content, { encoding: "utf8", flag: "w" });
+    const { rename: rename7 } = await import("fs/promises");
+    await rename7(tmp, filePath);
   } catch (err) {
-    await rm3(tmp, { force: true }).catch(() => {
+    await rm(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
-async function pathExists4(p) {
+async function pathExists2(p) {
   try {
-    await access3(p, fsConstants3.F_OK);
+    await access(p, fsConstants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function isDir2(p) {
+async function isDir(p) {
   try {
-    const s = await stat3(p);
+    const s = await stat(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -4304,28 +3390,28 @@ function parsePluginKey(key) {
   return { name: key.slice(0, at), marketplace: key.slice(at + 1) };
 }
 async function isFullyInstalledMirror(home, ref) {
-  const mktDir = resolve4(
+  const mktDir = resolve3(
     codexHomeDir(home),
     "plugins",
     "marketplaces",
     ref.marketplace
   );
-  const pluginDir = resolve4(mktDir, "plugins", ref.name);
-  if (!await isDir2(pluginDir)) return false;
-  const manifestPath = resolve4(pluginDir, ".codex-plugin", "plugin.json");
-  if (await pathExists4(manifestPath)) {
+  const pluginDir = resolve3(mktDir, "plugins", ref.name);
+  if (!await isDir(pluginDir)) return false;
+  const manifestPath = resolve3(pluginDir, ".codex-plugin", "plugin.json");
+  if (await pathExists2(manifestPath)) {
     try {
-      const raw = await readFile4(manifestPath, "utf8");
+      const raw = await readFile2(manifestPath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed["x-rush-mirror"] === "stub") return false;
     } catch {
       return false;
     }
   }
-  const mcpPath = resolve4(pluginDir, ".mcp.json");
-  if (await pathExists4(mcpPath)) {
+  const mcpPath = resolve3(pluginDir, ".mcp.json");
+  if (await pathExists2(mcpPath)) {
     try {
-      const raw = await readFile4(mcpPath, "utf8");
+      const raw = await readFile2(mcpPath, "utf8");
       if (/\$\{[^}]+\}/.test(raw)) return false;
     } catch {
       return false;
@@ -4334,30 +3420,30 @@ async function isFullyInstalledMirror(home, ref) {
   return true;
 }
 async function detectInstalledVersion(home, ref) {
-  const baseDir = resolve4(
+  const baseDir = resolve3(
     codexHomeDir(home),
     "plugins",
     "cache",
     ref.marketplace,
     ref.name
   );
-  if (!await isDir2(baseDir)) return null;
+  if (!await isDir(baseDir)) return null;
   let entries;
   try {
-    entries = await readdir2(baseDir);
+    entries = await readdir(baseDir);
   } catch {
     return null;
   }
   let best = null;
   for (const entry of entries) {
-    const versionDir = resolve4(baseDir, entry);
-    const manifestPath = resolve4(versionDir, ".codex-plugin", "plugin.json");
-    if (!await pathExists4(manifestPath)) continue;
+    const versionDir = resolve3(baseDir, entry);
+    const manifestPath = resolve3(versionDir, ".codex-plugin", "plugin.json");
+    if (!await pathExists2(manifestPath)) continue;
     try {
-      const raw = await readFile4(manifestPath, "utf8");
+      const raw = await readFile2(manifestPath, "utf8");
       const obj = JSON.parse(raw);
       const version = typeof obj.version === "string" && obj.version.length > 0 ? obj.version : entry;
-      const s = await stat3(versionDir);
+      const s = await stat(versionDir);
       if (!best || s.mtimeMs > best.mtimeMs) {
         best = { version, mtimeMs: s.mtimeMs };
       }
@@ -4379,28 +3465,28 @@ function defaultRushAiBinaryResolver() {
 }
 
 // src/marketplaces/cache.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { constants as fsConstants6 } from "fs";
+import { randomUUID } from "crypto";
+import { constants as fsConstants4 } from "fs";
 import {
-  access as access6,
-  mkdir as mkdir6,
-  readdir as readdir3,
-  readFile as readFile6,
-  rename as rename4,
-  rm as rm6,
-  writeFile as writeFile6
+  access as access4,
+  mkdir as mkdir3,
+  readdir as readdir2,
+  readFile as readFile4,
+  rename,
+  rm as rm3,
+  writeFile as writeFile3
 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname5, resolve as resolve9 } from "path";
+import { dirname as dirname3, resolve as resolve7 } from "path";
 
 // src/marketplaces/directory.ts
 import { stat as fsStat } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve5 } from "path";
 
 // src/marketplaces/manifest.ts
-import { constants as fsConstants4 } from "fs";
-import { access as access4, readFile as readFile5 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { constants as fsConstants2 } from "fs";
+import { access as access2, readFile as readFile3 } from "fs/promises";
+import { resolve as resolve4 } from "path";
 
 // src/marketplaces/source.ts
 import { isAbsolute as isAbsolute2 } from "path";
@@ -4599,9 +3685,9 @@ var MarketplaceCorruptError = class extends MarketplaceError {
   }
 };
 async function readMarketplaceJson(rootDir) {
-  const filePath = resolve5(rootDir, MARKETPLACE_MANIFEST_RELATIVE_PATH);
+  const filePath = resolve4(rootDir, MARKETPLACE_MANIFEST_RELATIVE_PATH);
   try {
-    await access4(filePath, fsConstants4.R_OK);
+    await access2(filePath, fsConstants2.R_OK);
   } catch {
     throw new MarketplaceCorruptError(
       filePath,
@@ -4609,7 +3695,7 @@ async function readMarketplaceJson(rootDir) {
       "file does not exist or is not readable"
     );
   }
-  const raw = await readFile5(filePath, "utf8");
+  const raw = await readFile3(filePath, "utf8");
   return parseMarketplaceJson(raw, filePath);
 }
 function parseMarketplaceJson(raw, sourcePathForError) {
@@ -4675,7 +3761,7 @@ async function resolveDirectoryMarketplace(source, name) {
       "marketplace name must be non-empty string"
     );
   }
-  const rootDir = resolve6(source.path);
+  const rootDir = resolve5(source.path);
   let stats;
   try {
     stats = await fsStat(rootDir);
@@ -4714,9 +3800,9 @@ async function ensureDirectoryExists(source) {
 
 // src/marketplaces/github.ts
 import { spawn } from "child_process";
-import { constants as fsConstants5 } from "fs";
-import { access as access5, rm as rm4 } from "fs/promises";
-import { resolve as resolve7 } from "path";
+import { constants as fsConstants3 } from "fs";
+import { access as access3, rm as rm2 } from "fs/promises";
+import { resolve as resolve6 } from "path";
 var GitCloneFailedError = class extends MarketplaceError {
   constructor(source, exitCode, stderr) {
     super(
@@ -4769,7 +3855,7 @@ async function cloneGithubMarketplace(source, cacheDir, name, opts) {
   if (existing === "missing") {
     await runClone(runner, url, cacheDir, source);
   } else if (existing === "not-git") {
-    await rm4(cacheDir, { recursive: true, force: true });
+    await rm2(cacheDir, { recursive: true, force: true });
     await runClone(runner, url, cacheDir, source);
   } else {
     await runUpdate(runner, cacheDir, source);
@@ -4777,7 +3863,7 @@ async function cloneGithubMarketplace(source, cacheDir, name, opts) {
   const manifest = await readMarketplaceJson(cacheDir);
   return {
     name,
-    rootDir: resolve7(cacheDir),
+    rootDir: resolve6(cacheDir),
     source,
     manifest
   };
@@ -4785,264 +3871,66 @@ async function cloneGithubMarketplace(source, cacheDir, name, opts) {
 async function updateGithubMarketplace(source, cacheDir, name, opts) {
   const runner = opts?.runner ?? defaultGitRunner;
   const state = await detectCacheState(cacheDir);
-  if (state !== "git") {
-    return cloneGithubMarketplace(source, cacheDir, name, opts);
-  }
-  await runUpdate(runner, cacheDir, source);
-  const manifest = await readMarketplaceJson(cacheDir);
-  return {
-    name,
-    rootDir: resolve7(cacheDir),
-    source,
-    manifest
-  };
-}
-async function runClone(runner, url, cacheDir, source) {
-  const args = ["clone", "--depth", "1"];
-  if (source.ref) {
-    args.push("--branch", source.ref);
-  }
-  args.push("--", url, cacheDir);
-  const result = await runner(args);
-  if (result.exitCode !== 0) {
-    throw new GitCloneFailedError(source, result.exitCode, result.stderr);
-  }
-}
-async function runUpdate(runner, cacheDir, source) {
-  const refArg = source.ref ?? "HEAD";
-  const fetchResult = await runner(
-    ["fetch", "--depth", "1", "origin", refArg],
-    { cwd: cacheDir }
-  );
-  if (fetchResult.exitCode !== 0) {
-    throw new GitCloneFailedError(
-      source,
-      fetchResult.exitCode,
-      fetchResult.stderr
-    );
-  }
-  const checkoutResult = await runner(
-    ["checkout", "--quiet", "--detach", "FETCH_HEAD"],
-    { cwd: cacheDir }
-  );
-  if (checkoutResult.exitCode !== 0) {
-    throw new GitCloneFailedError(
-      source,
-      checkoutResult.exitCode,
-      checkoutResult.stderr
-    );
-  }
-}
-async function detectCacheState(cacheDir) {
-  try {
-    await access5(cacheDir, fsConstants5.F_OK);
-  } catch {
-    return "missing";
-  }
-  try {
-    await access5(resolve7(cacheDir, ".git"), fsConstants5.F_OK);
-    return "git";
-  } catch {
-    return "not-git";
-  }
-}
-
-// src/marketplaces/rush.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir5, rename as rename3, rm as rm5, stat as stat4, writeFile as writeFile5 } from "fs/promises";
-import { resolve as resolve8 } from "path";
-async function fetchRushMarketplace(source, opts = {}) {
-  const fetchFn = opts.fetchFn ?? fetch;
-  const url = `${inferProtocol(source.host)}${source.host}/api/marketplace`;
-  const headers = {
-    Accept: "application/json"
-  };
-  if (opts.token) {
-    headers.Authorization = `Bearer ${opts.token}`;
-  }
-  const response = await fetchFn(url, { headers });
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch rush marketplace from ${url}: ${response.status} ${response.statusText}`
-    );
-  }
-  const data = await response.json();
-  if (!data.plugins || !Array.isArray(data.plugins)) {
-    throw new Error(
-      `Invalid marketplace response from ${url}: missing 'plugins' array`
-    );
-  }
-  return data;
-}
-async function fetchRushPlugin(source, pluginSlug, opts = {}) {
-  const fetchFn = opts.fetchFn ?? fetch;
-  const url = `${inferProtocol(source.host)}${source.host}/api/marketplace/${encodeURIComponent(pluginSlug)}`;
-  const headers = {
-    Accept: "application/json"
-  };
-  if (opts.token) {
-    headers.Authorization = `Bearer ${opts.token}`;
-  }
-  const response = await fetchFn(url, { headers });
-  if (response.status === 401) {
-    throw new Error(
-      `Plugin '${pluginSlug}' requires authentication. Run 'rush-ai login' first.`
-    );
-  }
-  if (response.status === 404) {
-    throw new Error(
-      `Plugin '${pluginSlug}' not found in rush marketplace at ${source.host}`
-    );
-  }
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch plugin '${pluginSlug}' from ${url}: ${response.status} ${response.statusText}`
-    );
-  }
-  return await response.json();
-}
-async function materializeRushPlugin(source, pluginSlug, targetDir, opts = {}) {
-  validateSlug(pluginSlug, "plugin slug");
-  const manifest = await fetchRushPlugin(source, pluginSlug, opts);
-  let mcpServers = {};
-  if (manifest.mcpServers && Object.keys(manifest.mcpServers).length > 0) {
-    mcpServers = { ...manifest.mcpServers };
-    if (opts.secrets && Object.keys(opts.secrets).length > 0) {
-      mcpServers = substituteMcpSecrets(mcpServers, opts.secrets);
-    }
-  }
-  const pluginJson = {
-    name: manifest.name,
-    version: manifest.version || "1.0.0",
-    description: manifest.description,
-    ...Object.keys(mcpServers).length > 0 ? { mcpServers } : {}
-  };
-  const tmpDir = `${targetDir}.${randomUUID3()}.tmp`;
-  try {
-    const pluginJsonDir = resolve8(tmpDir, ".claude-plugin");
-    await mkdir5(pluginJsonDir, { recursive: true });
-    await writeFile5(
-      resolve8(pluginJsonDir, "plugin.json"),
-      `${JSON.stringify(pluginJson, null, 2)}
-`,
-      "utf8"
-    );
-    if (manifest.skills && manifest.skills.length > 0) {
-      await writeFile5(
-        resolve8(tmpDir, "skills.json"),
-        '{"skills":{}}\n',
-        "utf8"
-      );
-      const registryUrl = `${inferProtocol(source.host)}${source.host}`;
-      for (const skill of manifest.skills) {
-        try {
-          const args = [
-            "-y",
-            "reskill@latest",
-            "install",
-            skill.name,
-            "--no-save",
-            "--skip-manifest",
-            "-y",
-            "-f",
-            "-r",
-            registryUrl,
-            ...opts.token ? ["-t", opts.token] : []
-          ];
-          execFileSync4("npx", args, {
-            cwd: tmpDir,
-            timeout: 6e4,
-            stdio: "pipe"
-          });
-        } catch (err) {
-          const stderr = err && typeof err === "object" && "stderr" in err ? err.stderr?.toString() ?? "" : "";
-          if (stderr.includes("401") || stderr.includes("403") || stderr.includes("Unauthorized") || stderr.includes("Forbidden")) {
-            throw new SkillAuthError(skill.name, 401);
-          }
-          output.warn(
-            `  Warning: failed to install skill '${skill.name}': ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-    }
-    const dotSkillsDir = resolve8(tmpDir, ".skills");
-    const skillsDir = resolve8(tmpDir, "skills");
-    if (await stat4(dotSkillsDir).then((s) => s.isDirectory()).catch(() => false)) {
-      if (!await stat4(skillsDir).then((s) => s.isDirectory()).catch(() => false)) {
-        await rename3(dotSkillsDir, skillsDir);
-      }
-    }
-    await rm5(resolve8(tmpDir, "skills.json"), { force: true });
-    await rm5(resolve8(tmpDir, ".cursor"), { recursive: true, force: true });
-    await rm5(resolve8(tmpDir, ".claude"), { recursive: true, force: true });
-    await rm5(resolve8(tmpDir, ".codex"), { recursive: true, force: true });
-    await rm5(resolve8(tmpDir, ".github"), { recursive: true, force: true });
-    await rm5(resolve8(tmpDir, ".opencode"), { recursive: true, force: true });
-    await rm5(targetDir, { recursive: true, force: true });
-    await mkdir5(resolve8(targetDir, ".."), { recursive: true });
-    await rename3(tmpDir, targetDir);
-  } catch (err) {
-    await rm5(tmpDir, { recursive: true, force: true }).catch(() => {
-    });
-    throw err;
+  if (state !== "git") {
+    return cloneGithubMarketplace(source, cacheDir, name, opts);
   }
-  return manifest;
+  await runUpdate(runner, cacheDir, source);
+  const manifest = await readMarketplaceJson(cacheDir);
+  return {
+    name,
+    rootDir: resolve6(cacheDir),
+    source,
+    manifest
+  };
 }
-var SkillAuthError = class extends Error {
-  constructor(skillName, status) {
-    super(
-      `Skill '${skillName}' requires authentication (HTTP ${status}). Run 'rush-ai auth login' first.`
-    );
-    this.name = "SkillAuthError";
+async function runClone(runner, url, cacheDir, source) {
+  const args = ["clone", "--depth", "1"];
+  if (source.ref) {
+    args.push("--branch", source.ref);
   }
-};
-function substituteMcpSecrets(mcpServers, secrets) {
-  const result = {};
-  for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
-    if (!serverConfig || typeof serverConfig !== "object") {
-      result[serverName] = serverConfig;
-      continue;
-    }
-    const cfg = { ...serverConfig };
-    if (cfg.env && typeof cfg.env === "object") {
-      const env = {};
-      for (const [k, v] of Object.entries(cfg.env)) {
-        env[k] = substituteValue(v, secrets);
-      }
-      cfg.env = env;
-    }
-    if (cfg.headers && typeof cfg.headers === "object") {
-      const headers = {};
-      for (const [k, v] of Object.entries(
-        cfg.headers
-      )) {
-        headers[k] = substituteValue(v, secrets);
-      }
-      cfg.headers = headers;
-    }
-    result[serverName] = cfg;
+  args.push("--", url, cacheDir);
+  const result = await runner(args);
+  if (result.exitCode !== 0) {
+    throw new GitCloneFailedError(source, result.exitCode, result.stderr);
   }
-  return result;
-}
-function substituteValue(value, secrets) {
-  return value.replace(/\$\{([^}]+)\}/g, (match, key) => {
-    return key in secrets ? secrets[key] : match;
-  });
 }
-function validateSlug(value, label) {
-  if (!value || value.includes("..") || value.startsWith("/") || value.includes("\0")) {
-    throw new Error(
-      `Invalid ${label} '${value}': must not be empty, contain '..', start with '/', or contain null bytes.`
+async function runUpdate(runner, cacheDir, source) {
+  const refArg = source.ref ?? "HEAD";
+  const fetchResult = await runner(
+    ["fetch", "--depth", "1", "origin", refArg],
+    { cwd: cacheDir }
+  );
+  if (fetchResult.exitCode !== 0) {
+    throw new GitCloneFailedError(
+      source,
+      fetchResult.exitCode,
+      fetchResult.stderr
+    );
+  }
+  const checkoutResult = await runner(
+    ["checkout", "--quiet", "--detach", "FETCH_HEAD"],
+    { cwd: cacheDir }
+  );
+  if (checkoutResult.exitCode !== 0) {
+    throw new GitCloneFailedError(
+      source,
+      checkoutResult.exitCode,
+      checkoutResult.stderr
     );
   }
 }
-function inferProtocol(host) {
-  const hostname = host.split(":")[0];
-  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0") {
-    return "http://";
+async function detectCacheState(cacheDir) {
+  try {
+    await access3(cacheDir, fsConstants3.F_OK);
+  } catch {
+    return "missing";
+  }
+  try {
+    await access3(resolve6(cacheDir, ".git"), fsConstants3.F_OK);
+    return "git";
+  } catch {
+    return "not-git";
   }
-  return "https://";
 }
 
 // src/marketplaces/cache.ts
@@ -5071,10 +3959,10 @@ var MarketplaceCache = class {
   gitRunner;
   constructor(opts = {}) {
     if (opts.cacheBaseDir) {
-      this.cacheBaseDir = resolve9(opts.cacheBaseDir);
+      this.cacheBaseDir = resolve7(opts.cacheBaseDir);
     } else {
       const home = opts.home ?? homedir4();
-      this.cacheBaseDir = resolve9(home, MARKETPLACE_CACHE_RELATIVE_PATH);
+      this.cacheBaseDir = resolve7(home, MARKETPLACE_CACHE_RELATIVE_PATH);
     }
     if (opts.gitRunner) {
       this.gitRunner = opts.gitRunner;
@@ -5087,7 +3975,7 @@ var MarketplaceCache = class {
         `Invalid marketplace name '${name}'. Names must be non-empty and cannot contain '/' or '..'.`
       );
     }
-    return resolve9(this.cacheBaseDir, name);
+    return resolve7(this.cacheBaseDir, name);
   }
   /**
    * 添加一个 marketplace 到本地 cache。
@@ -5127,7 +4015,7 @@ var MarketplaceCache = class {
         return resolved;
       }
       case "github": {
-        await mkdir6(dirname5(targetDir), { recursive: true });
+        await mkdir3(dirname3(targetDir), { recursive: true });
         const resolved = await cloneGithubMarketplace(
           source,
           targetDir,
@@ -5156,10 +4044,10 @@ var MarketplaceCache = class {
    */
   async remove(name) {
     const target = this.pathFor(name);
-    if (!await pathExists5(target)) {
+    if (!await pathExists3(target)) {
       return;
     }
-    await rm6(target, { recursive: true, force: true });
+    await rm3(target, { recursive: true, force: true });
   }
   /**
    * 重新 fetch 远端 source（仅对 github: / git: / rush:// / npm:）。
@@ -5207,10 +4095,10 @@ var MarketplaceCache = class {
    * v1 暂不单列损坏项；若未来需要，可加 `options.includeCorrupt` 返回 warning。
    */
   async list() {
-    if (!await pathExists5(this.cacheBaseDir)) {
+    if (!await pathExists3(this.cacheBaseDir)) {
       return [];
     }
-    const entries = await readdir3(this.cacheBaseDir, { withFileTypes: true });
+    const entries = await readdir2(this.cacheBaseDir, { withFileTypes: true });
     const result = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
@@ -5218,7 +4106,7 @@ var MarketplaceCache = class {
       if (!meta) continue;
       result.push({
         name: entry.name,
-        path: resolve9(this.cacheBaseDir, entry.name),
+        path: resolve7(this.cacheBaseDir, entry.name),
         source: meta.source,
         cachedAt: meta.cachedAt
       });
@@ -5291,20 +4179,20 @@ var MarketplaceCache = class {
     };
     const resolvedName = name ?? defaultNameFromSource(source);
     const rootDir = this.pathFor(resolvedName);
-    const manifestDir = resolve9(rootDir, ".claude-plugin");
-    await mkdir6(manifestDir, { recursive: true });
-    await atomicWriteJson(resolve9(manifestDir, "marketplace.json"), manifest);
+    const manifestDir = resolve7(rootDir, ".claude-plugin");
+    await mkdir3(manifestDir, { recursive: true });
+    await atomicWriteJson(resolve7(manifestDir, "marketplace.json"), manifest);
     return { name: resolvedName, rootDir, source, manifest };
   }
   metaPathFor(name) {
-    return resolve9(this.pathFor(name), CACHE_META_FILENAME);
+    return resolve7(this.pathFor(name), CACHE_META_FILENAME);
   }
   async readMeta(name) {
     const metaPath = this.metaPathFor(name);
-    if (!await pathExists5(metaPath)) {
+    if (!await pathExists3(metaPath)) {
       return null;
     }
-    const raw = await readFile6(metaPath, "utf8");
+    const raw = await readFile4(metaPath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -5334,7 +4222,7 @@ var MarketplaceCache = class {
   }
   async writeMeta(name, source) {
     const metaPath = this.metaPathFor(name);
-    await mkdir6(dirname5(metaPath), { recursive: true });
+    await mkdir3(dirname3(metaPath), { recursive: true });
     const payload = {
       sourceRaw: source.raw,
       cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5344,9 +4232,9 @@ var MarketplaceCache = class {
     await atomicWriteJson(metaPath, payload);
   }
 };
-async function pathExists5(p) {
+async function pathExists3(p) {
   try {
-    await access6(p, fsConstants6.F_OK);
+    await access4(p, fsConstants4.F_OK);
     return true;
   } catch {
     return false;
@@ -5355,237 +4243,17 @@ async function pathExists5(p) {
 async function atomicWriteJson(filePath, payload) {
   const content = `${JSON.stringify(payload, null, 2)}
 `;
-  const tmp = `${filePath}.${randomUUID4()}.tmp`;
+  const tmp = `${filePath}.${randomUUID()}.tmp`;
   try {
-    await writeFile6(tmp, content, { encoding: "utf8" });
-    await rename4(tmp, filePath);
+    await writeFile3(tmp, content, { encoding: "utf8" });
+    await rename(tmp, filePath);
   } catch (err) {
-    await rm6(tmp, { force: true }).catch(() => {
+    await rm3(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 
-// src/commands/marketplace/_codex-content-loader.ts
-import { constants as fsConstants7 } from "fs";
-import { access as access7, readFile as readFile7, stat as stat5 } from "fs/promises";
-import { resolve as pathResolve2, sep } from "path";
-function pickContentLoader(resolved, opts = {}) {
-  switch (resolved.source.kind) {
-    case "rush":
-      return buildRushPluginContentLoader(resolved.source, opts);
-    case "directory":
-    case "github":
-      return buildLocalCachePluginContentLoader(resolved);
-    default:
-      return async () => ({});
-  }
-}
-function buildRushPluginContentLoader(source, opts = {}) {
-  const token = opts.token ?? getAuthToken();
-  const fetchOpts = {};
-  if (opts.fetchFn !== void 0) fetchOpts.fetchFn = opts.fetchFn;
-  if (token !== void 0 && token !== null) fetchOpts.token = token;
-  const webBase = inferWebBase(source.host);
-  const fetchFn = opts.fetchFn ?? globalThis.fetch;
-  return async (entry) => {
-    if (typeof entry.name !== "string" || entry.name.length === 0) return {};
-    try {
-      const detail = await fetchRushPlugin(source, entry.name, fetchOpts);
-      const manifest = pickManifestFields(
-        detail
-      );
-      const hasMcp2 = detail.mcpServers && Object.keys(detail.mcpServers).length > 0;
-      const pluginWebUrl = `${webBase}/next/plugins/${encodeURIComponent(
-        entry.name
-      )}`;
-      const skillEntries = Array.isArray(detail.skills) && detail.skills.length > 0 ? detail.skills.filter(
-        (s) => !!s && typeof s.name === "string" && s.name.length > 0
-      ) : [];
-      const skillsPlaceholders = [];
-      for (const s of skillEntries) {
-        const url = `${webBase}/next/skills/${encodeURIComponent(s.name)}`;
-        const mdUrl = `${url}.md`;
-        let rawSkillMd;
-        try {
-          const headers = {
-            Accept: "text/markdown,text/plain,*/*"
-          };
-          if (token) headers.Authorization = `Bearer ${token}`;
-          const res = await fetchFn(mdUrl, { headers });
-          if (res.ok) {
-            const text = await res.text();
-            if (text.length > 0) rawSkillMd = text;
-          }
-        } catch {
-        }
-        skillsPlaceholders.push({
-          name: s.name,
-          url,
-          ...rawSkillMd !== void 0 ? { rawSkillMd } : {}
-        });
-      }
-      return {
-        ...manifest !== void 0 ? { manifest } : {},
-        ...hasMcp2 ? { mcpServers: detail.mcpServers } : {},
-        ...skillsPlaceholders.length > 0 ? { skillsPlaceholders } : {},
-        pluginWebUrl
-      };
-    } catch {
-      return {};
-    }
-  };
-}
-function inferWebBase(host) {
-  const hostname = host.split(":")[0];
-  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0") {
-    return `http://${host}`;
-  }
-  return `https://${host}`;
-}
-function buildLocalCachePluginContentLoader(resolved) {
-  return async (entry) => {
-    const relPath = extractLocalPluginPath(entry);
-    if (relPath === null) return {};
-    const pluginDir = pathResolve2(resolved.rootDir, relPath);
-    const root = pathResolve2(resolved.rootDir);
-    const rootWithSep = root.endsWith(sep) ? root : root + sep;
-    const safe = pluginDir === root || pluginDir.startsWith(rootWithSep);
-    if (!safe) return {};
-    let manifest;
-    let mcpServers;
-    let skillsSourceDir;
-    try {
-      const pj = await readFile7(
-        pathResolve2(pluginDir, ".claude-plugin", "plugin.json"),
-        "utf8"
-      );
-      const parsed = JSON.parse(pj);
-      manifest = pickManifestFields(parsed);
-      const inline = parsed.mcpServers;
-      if (inline && typeof inline === "object" && !Array.isArray(inline) && Object.keys(inline).length > 0) {
-        mcpServers = inline;
-      }
-    } catch {
-    }
-    try {
-      const raw = await readFile7(pathResolve2(pluginDir, ".mcp.json"), "utf8");
-      const parsed = JSON.parse(raw);
-      let servers = null;
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "mcpServers" in parsed && typeof parsed.mcpServers === "object") {
-        servers = parsed.mcpServers;
-      } else if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        servers = parsed;
-      }
-      if (servers && Object.keys(servers).length > 0) {
-        mcpServers = servers;
-      }
-    } catch {
-    }
-    const skillsDir = pathResolve2(pluginDir, "skills");
-    if (await isDir3(skillsDir)) {
-      skillsSourceDir = skillsDir;
-    }
-    return {
-      ...manifest !== void 0 ? { manifest } : {},
-      ...mcpServers !== void 0 ? { mcpServers } : {},
-      ...skillsSourceDir !== void 0 ? { skillsSourceDir } : {}
-    };
-  };
-}
-function extractLocalPluginPath(entry) {
-  if (typeof entry.source === "string") {
-    return entry.source;
-  }
-  if (entry.source && typeof entry.source === "object" && !Array.isArray(entry.source)) {
-    const obj = entry.source;
-    if (typeof obj.url === "string" && obj.url.length > 0) {
-      return null;
-    }
-    if (typeof obj.path === "string" && obj.path.length > 0) {
-      return obj.path;
-    }
-  }
-  if (entry.source === void 0 && typeof entry.name === "string" && entry.name.length > 0) {
-    return `plugins/${entry.name}`;
-  }
-  return null;
-}
-async function isDir3(p) {
-  try {
-    const s = await stat5(p);
-    return s.isDirectory();
-  } catch {
-    return false;
-  }
-}
-function pickManifestFields(raw) {
-  const m = {};
-  if (typeof raw.description === "string" && raw.description.length > 0) {
-    m.description = raw.description;
-  }
-  if (typeof raw.version === "string" && raw.version.length > 0) {
-    m.version = raw.version;
-  }
-  if (typeof raw.homepage === "string" && raw.homepage.length > 0) {
-    m.homepage = raw.homepage;
-  }
-  if (typeof raw.license === "string" && raw.license.length > 0) {
-    m.license = raw.license;
-  }
-  if (Array.isArray(raw.keywords)) {
-    const kw = raw.keywords.filter(
-      (x) => typeof x === "string" && x.length > 0
-    );
-    if (kw.length > 0) m.keywords = kw;
-  }
-  if (raw.author && typeof raw.author === "object" && !Array.isArray(raw.author)) {
-    const a = raw.author;
-    const author = {};
-    if (typeof a.name === "string") author.name = a.name;
-    if (typeof a.email === "string") author.email = a.email;
-    if (typeof a.url === "string") author.url = a.url;
-    if (Object.keys(author).length > 0) m.author = author;
-  }
-  if (raw.interface && typeof raw.interface === "object" && !Array.isArray(raw.interface)) {
-    const iface = pickInterfaceFields(raw.interface);
-    if (iface !== void 0) m.interface = iface;
-  }
-  return Object.keys(m).length > 0 ? m : void 0;
-}
-function pickInterfaceFields(raw) {
-  const out = {};
-  const stringKeys = [
-    "displayName",
-    "shortDescription",
-    "longDescription",
-    "developerName",
-    "category",
-    "websiteURL",
-    "privacyPolicyURL",
-    "termsOfServiceURL",
-    "brandColor",
-    "composerIcon",
-    "logo"
-  ];
-  for (const key of stringKeys) {
-    const v = raw[key];
-    if (typeof v === "string" && v.length > 0) {
-      out[key] = v;
-    }
-  }
-  for (const key of ["capabilities", "defaultPrompt", "screenshots"]) {
-    const v = raw[key];
-    if (Array.isArray(v)) {
-      const arr = v.filter(
-        (x) => typeof x === "string" && x.length > 0
-      );
-      if (arr.length > 0) out[key] = arr;
-    }
-  }
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-
 // src/commands/marketplace/add.ts
 async function runAdd(input) {
   let source;
@@ -5717,19 +4385,19 @@ function registerAddCommand(group, _root) {
 }
 
 // src/installers/registry.ts
-import { randomUUID as randomUUID5 } from "crypto";
-import { constants as fsConstants8 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { constants as fsConstants5 } from "fs";
 import {
-  access as access8,
-  mkdir as mkdir7,
-  readFile as readFile8,
-  rename as rename5,
-  rm as rm7,
-  stat as stat6,
-  writeFile as writeFile7
+  access as access5,
+  mkdir as mkdir4,
+  readFile as readFile5,
+  rename as rename2,
+  rm as rm4,
+  stat as stat2,
+  writeFile as writeFile4
 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname6, resolve as resolve10 } from "path";
+import { dirname as dirname4, resolve as resolve8 } from "path";
 var REGISTRY_RELATIVE_PATH = ".rush/plugins/registry.json";
 var REGISTRY_SCHEMA_VERSION = 1;
 var RushRegistryError = class extends Error {
@@ -5809,35 +4477,35 @@ function assertRegistryShape(raw, filePath) {
     );
   }
 }
-async function pathExists6(p) {
+async function pathExists4(p) {
   try {
-    await access8(p, fsConstants8.F_OK);
+    await access5(p, fsConstants5.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function atomicWrite2(filePath, content) {
-  await mkdir7(dirname6(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID5()}.tmp`;
+async function atomicWrite(filePath, content) {
+  await mkdir4(dirname4(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID2()}.tmp`;
   try {
-    await writeFile7(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename5(tmp, filePath);
+    await writeFile4(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename2(tmp, filePath);
   } catch (err) {
-    await rm7(tmp, { force: true }).catch(() => {
+    await rm4(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function loadFromPath(filePath) {
-  if (!await pathExists6(filePath)) {
+  if (!await pathExists4(filePath)) {
     return {
       data: { schemaVersion: REGISTRY_SCHEMA_VERSION, plugins: {} },
       mtimeMs: null
     };
   }
-  const stats = await stat6(filePath);
-  const raw = await readFile8(filePath, "utf8");
+  const stats = await stat2(filePath);
+  const raw = await readFile5(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -5886,7 +4554,7 @@ var RushRegistryStore = class _RushRegistryStore {
    */
   static resolvePath(opts) {
     const home = opts?.home ?? homedir6();
-    return resolve10(home, REGISTRY_RELATIVE_PATH);
+    return resolve8(home, REGISTRY_RELATIVE_PATH);
   }
   /**
    * 读取 registry 文件。
@@ -5937,20 +4605,20 @@ var RushRegistryStore = class _RushRegistryStore {
   async saveWithRetry(attempt) {
     this.assertWriteableSchema();
     if (this.loadedMtimeMs === null) {
-      if (await pathExists6(this.filePath)) {
+      if (await pathExists4(this.filePath)) {
         if (attempt === 0) {
           await this.reloadAndMerge();
           return this.saveWithRetry(1);
         }
         throw new RushRegistryConflictError(this.filePath);
       }
-      await atomicWrite2(this.filePath, this.serialize());
-      const stats2 = await stat6(this.filePath);
+      await atomicWrite(this.filePath, this.serialize());
+      const stats2 = await stat2(this.filePath);
       this.loadedMtimeMs = stats2.mtimeMs;
       this.deletedPluginKeys.clear();
       return;
     }
-    const stats = await stat6(this.filePath).catch(() => null);
+    const stats = await stat2(this.filePath).catch(() => null);
     if (stats === null) {
       if (attempt === 0) {
         await this.reloadAndMerge();
@@ -5965,8 +4633,8 @@ var RushRegistryStore = class _RushRegistryStore {
       }
       throw new RushRegistryConflictError(this.filePath);
     }
-    await atomicWrite2(this.filePath, this.serialize());
-    const afterStats = await stat6(this.filePath);
+    await atomicWrite(this.filePath, this.serialize());
+    const afterStats = await stat2(this.filePath);
     this.loadedMtimeMs = afterStats.mtimeMs;
     this.deletedPluginKeys.clear();
   }
@@ -6134,7 +4802,7 @@ function registerListCommand(group, root) {
 }
 
 // src/commands/marketplace/remove.ts
-import { rm as rm8 } from "fs/promises";
+import { rm as rm5 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 async function runRemove(input) {
   const homeOpts = input.home !== void 0 ? { home: input.home } : {};
@@ -6170,10 +4838,10 @@ async function runRemove(input) {
 }
 async function cleanupCodexMarketplace(home, name, now) {
   const codexHome = codexHomeDir(home);
-  if (!await pathExists5(codexHome)) return "absent";
+  if (!await pathExists3(codexHome)) return "absent";
   let didSomething = false;
   const cfgPath = codexConfigTomlPath(home);
-  if (await pathExists5(cfgPath)) {
+  if (await pathExists3(cfgPath)) {
     try {
       await backupCodexConfig(cfgPath, codexConfigBackupPath(home, now()));
       const { data, mtimeMs } = await readCodexConfig(cfgPath);
@@ -6188,8 +4856,8 @@ async function cleanupCodexMarketplace(home, name, now) {
     }
   }
   const mirrorDir = codexMarketplaceDir(home, name);
-  if (await pathExists5(mirrorDir)) {
-    await rm8(mirrorDir, { recursive: true, force: true }).catch(() => {
+  if (await pathExists3(mirrorDir)) {
+    await rm5(mirrorDir, { recursive: true, force: true }).catch(() => {
     });
     didSomething = true;
   }
@@ -6566,7 +5234,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-Y2CXHDCK.js");
+    const { startMcpServer } = await import("./server-PGXKRIPY.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(
@@ -6688,7 +5356,7 @@ function registerMcpCommand(program) {
     "Set credential values (e.g. --set TOKEN=xxx KEY=yyy)"
   ).action(async (mcpId, opts) => {
     const format = resolveFormat(program.opts());
-    const { runMcpInstall, printMcpInstallSummary } = await import("./install-IH2VPYXH.js");
+    const { runMcpInstall, printMcpInstallSummary } = await import("./install-JQN4BIHX.js");
     let setValues;
     if (opts.set) {
       setValues = {};
@@ -6749,7 +5417,7 @@ function registerMcpCommand(program) {
     "Comma-separated targets: claude-desktop,claude-code (default: both)"
   ).action(async (mcpId, opts) => {
     const format = resolveFormat(program.opts());
-    const { runMcpUninstall, printMcpUninstallSummary } = await import("./install-IH2VPYXH.js");
+    const { runMcpUninstall, printMcpUninstallSummary } = await import("./install-JQN4BIHX.js");
     try {
       const result = await runMcpUninstall({
         mcpId,
@@ -6783,7 +5451,7 @@ function registerMcpCommand(program) {
 
 // src/commands/playbook/index.ts
 import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync7 } from "fs";
-import { basename as basename4, resolve as resolve11 } from "path";
+import { basename as basename3, resolve as resolve9 } from "path";
 var PLAYBOOK_DESCRIPTION = "Print agent usage playbooks (hand-off, agent-shelf, ...) as raw markdown.";
 var PLAYBOOK_HELP_AFTER = `
 Examples:
@@ -6800,19 +5468,19 @@ function resolvePlaybooksDir() {
   const baseDir = import.meta.dirname ?? __dirname;
   if (!baseDir) return null;
   const candidates = [
-    resolve11(baseDir, "skills"),
-    resolve11(baseDir, "..", "skills"),
-    resolve11(baseDir, "..", "..", "skills"),
-    resolve11(baseDir, "..", "..", "..", "skills"),
-    resolve11(baseDir, "..", "..", "..", "..", "skills")
+    resolve9(baseDir, "skills"),
+    resolve9(baseDir, "..", "skills"),
+    resolve9(baseDir, "..", "..", "skills"),
+    resolve9(baseDir, "..", "..", "..", "skills"),
+    resolve9(baseDir, "..", "..", "..", "..", "skills")
   ];
   for (const p of candidates) {
-    if (existsSync11(resolve11(p, ".rush-playbooks"))) return p;
+    if (existsSync11(resolve9(p, ".rush-playbooks"))) return p;
   }
   return null;
 }
 function listPlaybooks(dir) {
-  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => basename4(f, ".md")).sort();
+  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => basename3(f, ".md")).sort();
 }
 function getAvailablePlaybooks() {
   const dir = resolvePlaybooksDir();
@@ -6837,7 +5505,7 @@ function printPlaybook(name, opts = {}) {
     return;
   }
   const target = name ?? "README";
-  const file2 = resolve11(dir, `${target}.md`);
+  const file2 = resolve9(dir, `${target}.md`);
   if (!existsSync11(file2)) {
     output.error(`Unknown playbook "${target}".`);
     output.dim(`Available: ${available.join(", ") || "(none)"}`);
@@ -6853,78 +5521,30 @@ function registerPlaybookCommand(program) {
 }
 
 // src/commands/plugin/install.ts
-import { rm as rm14 } from "fs/promises";
-import { resolve as resolve22 } from "path";
+import { rm as rm11 } from "fs/promises";
+import { homedir as homedir17 } from "os";
+import { resolve as resolve20 } from "path";
 
 // src/installers/claude-code/installer.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import {
-  copyFile as copyFile2,
+  copyFile,
   lstat,
-  mkdir as mkdir8,
-  readdir as readdir4,
-  readFile as readFile9,
+  mkdir as mkdir5,
+  readdir as readdir3,
+  readFile as readFile6,
   readlink,
-  rename as rename6,
-  rm as rm9,
-  stat as stat7,
+  rename as rename3,
+  rm as rm6,
+  stat as stat3,
   symlink,
   unlink
 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname7, join as join9, resolve as resolve13 } from "path";
-
-// src/installers/claude-code/mcp.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import { isAbsolute as isAbsolute3 } from "path";
-var RUSH_AI_PLUGIN_NAME2 = "rush";
-var RUSH_AI_MARKETPLACE_NAME2 = "rush-marketplace";
-var RUSH_MCP_SERVER_KEY2 = "rush";
-function isRushOwnPlugin(ref) {
-  return ref.name === RUSH_AI_PLUGIN_NAME2 && ref.marketplace === RUSH_AI_MARKETPLACE_NAME2;
-}
-function normalizeClaudeMcpServers(ref, manifest, resolver = defaultRushBinaryResolver) {
-  const servers = manifest.mcpServers;
-  if (servers === void 0 || servers === null) return void 0;
-  if (typeof servers === "string") {
-    return void 0;
-  }
-  if (!isRushOwnPlugin(ref)) {
-    return { ...servers };
-  }
-  const rushServer = servers[RUSH_MCP_SERVER_KEY2];
-  if (!rushServer) {
-    return { ...servers };
-  }
-  const currentCommand = rushServer.command;
-  if (typeof currentCommand === "string" && isAbsolute3(currentCommand)) {
-    return { ...servers };
-  }
-  const resolved = resolver();
-  if (!resolved || !isAbsolute3(resolved)) {
-    return { ...servers };
-  }
-  return {
-    ...servers,
-    [RUSH_MCP_SERVER_KEY2]: { ...rushServer, command: resolved }
-  };
-}
-function defaultRushBinaryResolver() {
-  try {
-    const result = execFileSync5("which", ["rush-ai"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    if (result.length > 0 && isAbsolute3(result)) {
-      return result;
-    }
-  } catch {
-  }
-  return void 0;
-}
+import { dirname as dirname5, join as join9, resolve as resolve11 } from "path";
 
 // src/installers/claude-code/paths.ts
-import { resolve as resolve12 } from "path";
+import { resolve as resolve10 } from "path";
 var CLAUDE_DIR = ".claude";
 var PLUGINS_SUBDIR = "plugins";
 var CACHE_SUBDIR = "cache";
@@ -6942,27 +5562,27 @@ var ClaudeCodePaths = class {
   }
   /** `<home>/.claude/` */
   get claudeDir() {
-    return resolve12(this.home, CLAUDE_DIR);
+    return resolve10(this.home, CLAUDE_DIR);
   }
   /** `<home>/.claude/settings.json` */
   get settingsJson() {
-    return resolve12(this.claudeDir, "settings.json");
+    return resolve10(this.claudeDir, "settings.json");
   }
   /** `<home>/.claude/plugins/` */
   get pluginsDir() {
-    return resolve12(this.claudeDir, PLUGINS_SUBDIR);
+    return resolve10(this.claudeDir, PLUGINS_SUBDIR);
   }
   /** `<home>/.claude/plugins/known_marketplaces.json` */
   get knownMarketplacesJson() {
-    return resolve12(this.pluginsDir, "known_marketplaces.json");
+    return resolve10(this.pluginsDir, "known_marketplaces.json");
   }
   /** `<home>/.claude/plugins/installed_plugins.json` */
   get installedPluginsJson() {
-    return resolve12(this.pluginsDir, "installed_plugins.json");
+    return resolve10(this.pluginsDir, "installed_plugins.json");
   }
   /** `<home>/.claude/plugins/cache/` */
   get cacheDir() {
-    return resolve12(this.pluginsDir, CACHE_SUBDIR);
+    return resolve10(this.pluginsDir, CACHE_SUBDIR);
   }
   /**
    * `<home>/.claude/plugins/marketplaces/`。
@@ -6972,34 +5592,34 @@ var ClaudeCodePaths = class {
    * Claude Code 会识别不到 plugin 条目（regression fix，bug #4）。
    */
   get marketplacesRootDir() {
-    return resolve12(this.pluginsDir, "marketplaces");
+    return resolve10(this.pluginsDir, "marketplaces");
   }
   /** `<home>/.claude/plugins/marketplaces/<mkt>/` */
   marketplaceInstallDir(marketplace) {
-    return resolve12(this.marketplacesRootDir, marketplace);
+    return resolve10(this.marketplacesRootDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/` */
   marketplaceCacheDir(marketplace) {
-    return resolve12(this.cacheDir, marketplace);
+    return resolve10(this.cacheDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/` */
   pluginCacheDir(ref) {
-    return resolve12(this.marketplaceCacheDir(ref.marketplace), ref.name);
+    return resolve10(this.marketplaceCacheDir(ref.marketplace), ref.name);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/` */
   pluginVersionDir(ref, version) {
-    return resolve12(this.pluginCacheDir(ref), version);
+    return resolve10(this.pluginCacheDir(ref), version);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/.claude-plugin/plugin.json` */
   pluginManifestPath(ref, version) {
-    return resolve12(
+    return resolve10(
       this.pluginVersionDir(ref, version),
       PLUGIN_MANIFEST_RELATIVE
     );
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/<capability>/` */
   capabilityDir(ref, version, capability) {
-    return resolve12(this.pluginVersionDir(ref, version), capability);
+    return resolve10(this.pluginVersionDir(ref, version), capability);
   }
 };
 function pluginKey(ref) {
@@ -7113,29 +5733,29 @@ var ClaudeCodeInstaller = class {
     }
     try {
       const writtenFiles = [];
-      await mkdir8(pluginVersionDir, { recursive: true });
+      await mkdir5(pluginVersionDir, { recursive: true });
       writtenFiles.push(pluginVersionDir);
       for (const cap of CAPABILITY_DIRS) {
-        const srcDir = resolve13(plugin.sourceDir, cap);
+        const srcDir = resolve11(plugin.sourceDir, cap);
         if (!await dirExists(srcDir)) continue;
         const dstDir = this.paths.capabilityDir(ref, version, cap);
-        await mkdir8(dstDir, { recursive: true });
+        await mkdir5(dstDir, { recursive: true });
         writtenFiles.push(dstDir);
         const copied = await copyDirTracked(srcDir, dstDir);
         writtenFiles.push(...copied);
       }
       const manifestPath = this.paths.pluginManifestPath(ref, version);
-      const normalizedMcp = normalizeClaudeMcpServers(
+      const normalizedMcp = await resolveClaudeMcpServers(
         ref,
-        plugin.manifest,
+        plugin,
         this.rushBinaryResolver
       );
       if (normalizedMcp && Object.keys(normalizedMcp).length > 0) {
-        const mcpJsonPath = resolve13(pluginVersionDir, ".mcp.json");
+        const mcpJsonPath = resolve11(pluginVersionDir, ".mcp.json");
         await writeJsonFile(mcpJsonPath, { mcpServers: normalizedMcp });
         writtenFiles.push(mcpJsonPath);
       }
-      const pluginJsonContent = buildPluginJson2(plugin, normalizedMcp);
+      const pluginJsonContent = buildPluginJson(plugin, normalizedMcp);
       await writeJsonFile(manifestPath, pluginJsonContent);
       writtenFiles.push(manifestPath);
       const mcpKeys = normalizedMcp ? Object.keys(normalizedMcp) : [];
@@ -7260,7 +5880,7 @@ var ClaudeCodeInstaller = class {
       files.push(mktDir);
     } else if (kind === "dir") {
       if (await pathExists(join9(mktDir, ".rush-marketplace-source.json"))) {
-        await rm9(mktDir, { recursive: true, force: true });
+        await rm6(mktDir, { recursive: true, force: true });
         files.push(mktDir);
       }
     }
@@ -7331,12 +5951,12 @@ var ClaudeCodeInstaller = class {
       return { written: false, path: "" };
     }
     const mktDir = this.paths.marketplaceInstallDir(marketplaceName);
-    await mkdir8(this.paths.marketplacesRootDir, { recursive: true });
+    await mkdir5(this.paths.marketplacesRootDir, { recursive: true });
     const kind = await inodeKind(mktDir);
     if (kind === "symlink") {
       const target = await readlink(mktDir).catch(() => null);
-      const resolvedTarget = target !== null ? resolve13(dirname7(mktDir), target) : null;
-      if (resolvedTarget && resolvedTarget === resolve13(src.rootDir)) {
+      const resolvedTarget = target !== null ? resolve11(dirname5(mktDir), target) : null;
+      if (resolvedTarget && resolvedTarget === resolve11(src.rootDir)) {
         return { written: false, path: mktDir };
       }
       throw new Error(
@@ -7369,7 +5989,7 @@ var ClaudeCodeInstaller = class {
       return { written: true, path: mktDir };
     }
     await copyDirTracked(src.rootDir, mktDir).catch(async (err) => {
-      await rm9(mktDir, { recursive: true, force: true }).catch(() => {
+      await rm6(mktDir, { recursive: true, force: true }).catch(() => {
       });
       throw err;
     });
@@ -7405,7 +6025,7 @@ var ClaudeCodeInstaller = class {
     const pluginVersionDir = this.paths.pluginVersionDir(ref, version);
     const dryFiles = [pluginVersionDir];
     for (const cap of CAPABILITY_DIRS) {
-      const srcDir = resolve13(plugin.sourceDir, cap);
+      const srcDir = resolve11(plugin.sourceDir, cap);
       if (!await dirExists(srcDir)) continue;
       const dstDir = this.paths.capabilityDir(ref, version, cap);
       dryFiles.push(dstDir);
@@ -7413,13 +6033,13 @@ var ClaudeCodeInstaller = class {
       dryFiles.push(...plannedFiles);
     }
     dryFiles.push(this.paths.pluginManifestPath(ref, version));
-    const normalizedMcpDry = normalizeClaudeMcpServers(
+    const normalizedMcpDry = await resolveClaudeMcpServers(
       ref,
-      plugin.manifest,
+      plugin,
       this.rushBinaryResolver
     );
     if (normalizedMcpDry && Object.keys(normalizedMcpDry).length > 0) {
-      dryFiles.push(resolve13(pluginVersionDir, ".mcp.json"));
+      dryFiles.push(resolve11(pluginVersionDir, ".mcp.json"));
     }
     if (this.marketplaceSource) {
       const mktInstallDir = this.paths.marketplaceInstallDir(ref.marketplace);
@@ -7436,9 +6056,9 @@ var ClaudeCodeInstaller = class {
     if (await this.wouldSettingsChange(pluginKey(ref))) {
       dryFiles.push(this.paths.settingsJson);
     }
-    const normalizedMcp = normalizeClaudeMcpServers(
+    const normalizedMcp = await resolveClaudeMcpServers(
       ref,
-      plugin.manifest,
+      plugin,
       this.rushBinaryResolver
     );
     const mcpKeys = normalizedMcp ? Object.keys(normalizedMcp) : [];
@@ -7533,8 +6153,8 @@ var ClaudeCodeInstaller = class {
     const settings = await this.readRawJsonForRollback(this.paths.settingsJson);
     let backupVersionDir = null;
     if (preexistedVersion === "dir") {
-      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID6()}`;
-      await rename6(pluginVersionDir, backupVersionDir);
+      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID3()}`;
+      await rename3(pluginVersionDir, backupVersionDir);
     }
     return {
       ref,
@@ -7555,7 +6175,7 @@ var ClaudeCodeInstaller = class {
    */
   async finalizeRollback(snap) {
     if (snap.backupVersionDir) {
-      await rm9(snap.backupVersionDir, { recursive: true, force: true });
+      await rm6(snap.backupVersionDir, { recursive: true, force: true });
     }
   }
   /**
@@ -7568,19 +6188,19 @@ var ClaudeCodeInstaller = class {
    */
   async applyRollback(snap) {
     if (snap.preexistedVersion === "dir" && snap.backupVersionDir) {
-      await rm9(snap.pluginVersionDir, { recursive: true, force: true });
-      await rename6(snap.backupVersionDir, snap.pluginVersionDir);
+      await rm6(snap.pluginVersionDir, { recursive: true, force: true });
+      await rename3(snap.backupVersionDir, snap.pluginVersionDir);
     } else if (snap.preexistedVersion === "missing") {
-      await rm9(snap.pluginVersionDir, { recursive: true, force: true });
+      await rm6(snap.pluginVersionDir, { recursive: true, force: true });
     }
     if (snap.preexistedPlugin === "missing") {
-      await rm9(this.paths.pluginCacheDir(snap.ref), {
+      await rm6(this.paths.pluginCacheDir(snap.ref), {
         recursive: true,
         force: true
       });
     }
     if (snap.preexistedMarketplace === "missing") {
-      await rm9(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
+      await rm6(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
         recursive: true,
         force: true
       });
@@ -7594,7 +6214,7 @@ var ClaudeCodeInstaller = class {
         await unlink(mktInstallDir).catch(() => {
         });
       } else if (currentKind !== "missing") {
-        await rm9(mktInstallDir, { recursive: true, force: true }).catch(
+        await rm6(mktInstallDir, { recursive: true, force: true }).catch(
           () => {
           }
         );
@@ -7617,7 +6237,7 @@ var ClaudeCodeInstaller = class {
   async restoreRawJson(path4, state) {
     if (!state.existed) {
       if (await pathExists(path4)) {
-        await rm9(path4, { force: true });
+        await rm6(path4, { force: true });
       }
       return;
     }
@@ -7869,7 +6489,7 @@ var ClaudeCodeInstaller = class {
     );
     const servers = data.mcpServers;
     if (typeof servers === "string") {
-      const mcpJsonPath = resolve13(dirname7(manifestPath), "..", servers);
+      const mcpJsonPath = resolve11(dirname5(manifestPath), "..", servers);
       if (!await pathExists(mcpJsonPath)) return [];
       const { data: mcpData } = await readJsonFile(
         mcpJsonPath,
@@ -7914,7 +6534,24 @@ function parsePluginKey2(key) {
   if (at <= 0 || at === key.length - 1) return null;
   return { name: key.slice(0, at), marketplace: key.slice(at + 1) };
 }
-function buildPluginJson2(plugin, mcpServers) {
+async function resolveClaudeMcpServers(ref, plugin, rushBinaryResolver) {
+  const decl = plugin.manifest.mcpServers;
+  if (decl === void 0 || decl === null) return void 0;
+  if (typeof decl === "object") {
+    return normalizeClaudeMcpServers(ref, plugin.manifest, rushBinaryResolver);
+  }
+  if (typeof decl === "string") {
+    const external = await readExternalMcpServers(plugin.sourceDir, decl);
+    if (!external || Object.keys(external).length === 0) return void 0;
+    return normalizeClaudeMcpServers(
+      ref,
+      { ...plugin.manifest, mcpServers: external },
+      rushBinaryResolver
+    );
+  }
+  return void 0;
+}
+function buildPluginJson(plugin, mcpServers) {
   const { manifest } = plugin;
   const {
     mcpServers: _origMcp,
@@ -7930,7 +6567,7 @@ function buildPluginJson2(plugin, mcpServers) {
 }
 async function readMarketplaceCacheSource(metaPath) {
   try {
-    const raw = await readFile9(metaPath, "utf8");
+    const raw = await readFile6(metaPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const sourceRaw = parsed.sourceRaw;
@@ -7965,7 +6602,7 @@ async function defaultSymlinkRunner(target, linkPath) {
 }
 async function dirExists(p) {
   try {
-    const s = await stat7(p);
+    const s = await stat3(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -7984,7 +6621,7 @@ async function inodeKind(p) {
 }
 async function listDirFilesRecursive(srcDir, dstDir) {
   const planned = [];
-  const entries = await readdir4(srcDir, { withFileTypes: true });
+  const entries = await readdir3(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = join9(srcDir, entry.name);
     const dstPath = join9(dstDir, entry.name);
@@ -8000,18 +6637,18 @@ async function listDirFilesRecursive(srcDir, dstDir) {
 }
 async function copyDirTracked(srcDir, dstDir) {
   const written = [];
-  const entries = await readdir4(srcDir, { withFileTypes: true });
+  const entries = await readdir3(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = join9(srcDir, entry.name);
     const dstPath = join9(dstDir, entry.name);
     if (entry.isDirectory()) {
-      await mkdir8(dstPath, { recursive: true });
+      await mkdir5(dstPath, { recursive: true });
       written.push(dstPath);
       const subWritten = await copyDirTracked(srcPath, dstPath);
       written.push(...subWritten);
     } else if (entry.isFile()) {
-      await mkdir8(dirname7(dstPath), { recursive: true });
-      await copyFile2(srcPath, dstPath);
+      await mkdir5(dirname5(dstPath), { recursive: true });
+      await copyFile(srcPath, dstPath);
       written.push(dstPath);
     }
   }
@@ -8021,7 +6658,7 @@ async function writeAtomicWithMtimeCheck(filePath, data, expectedMtimeMs) {
   if (expectedMtimeMs !== null) {
     let currentMtime = null;
     try {
-      const s = await stat7(filePath);
+      const s = await stat3(filePath);
       currentMtime = s.mtimeMs;
     } catch {
       currentMtime = null;
@@ -8044,20 +6681,20 @@ async function retryOnConflict(fn) {
 }
 
 // src/installers/cursor/installer.ts
-import { randomUUID as randomUUID8 } from "crypto";
-import { constants as fsConstants10 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { constants as fsConstants7 } from "fs";
 import {
-  access as access10,
-  cp as cp3,
-  mkdir as mkdir10,
-  readFile as readFile12,
-  rename as rename8,
-  rm as rm11,
-  stat as stat9,
-  writeFile as writeFile9
+  access as access7,
+  cp as cp2,
+  mkdir as mkdir7,
+  readFile as readFile9,
+  rename as rename5,
+  rm as rm8,
+  stat as stat5,
+  writeFile as writeFile6
 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname9, relative, resolve as resolve16 } from "path";
+import { dirname as dirname7, relative, resolve as resolve14 } from "path";
 
 // src/installers/cursor/marker.ts
 var RUSH_AI_MARKER = "<!-- rush-ai:auto-generated -->";
@@ -8066,27 +6703,27 @@ function hasRushAiMarker(fileContent) {
 }
 
 // src/installers/cursor/mcp.ts
-import { randomUUID as randomUUID7 } from "crypto";
-import { constants as fsConstants9 } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+import { constants as fsConstants6 } from "fs";
 import {
-  access as access9,
-  mkdir as mkdir9,
-  readFile as readFile10,
-  rename as rename7,
-  rm as rm10,
-  stat as stat8,
-  writeFile as writeFile8
+  access as access6,
+  mkdir as mkdir6,
+  readFile as readFile7,
+  rename as rename4,
+  rm as rm7,
+  stat as stat4,
+  writeFile as writeFile5
 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname6 } from "path";
 async function readCursorMcpJson(filePath) {
   return (await readCursorMcpJsonWithMtime(filePath)).data;
 }
 async function readCursorMcpJsonWithMtime(filePath) {
-  if (!await pathExists7(filePath)) {
+  if (!await pathExists5(filePath)) {
     return { data: {}, mtimeMs: null };
   }
-  const stats = await stat8(filePath);
-  const raw = await readFile10(filePath, "utf8");
+  const stats = await stat4(filePath);
+  const raw = await readFile7(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -8153,22 +6790,22 @@ function removeMcpServers(current, keysToRemove) {
   return cloned;
 }
 async function writeCursorMcpJson(filePath, data) {
-  await mkdir9(dirname8(filePath), { recursive: true });
+  await mkdir6(dirname6(filePath), { recursive: true });
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  const tmp = `${filePath}.${randomUUID7()}.tmp`;
+  const tmp = `${filePath}.${randomUUID4()}.tmp`;
   try {
-    await writeFile8(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename7(tmp, filePath);
+    await writeFile5(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename4(tmp, filePath);
   } catch (err) {
-    await rm10(tmp, { force: true }).catch(() => {
+    await rm7(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
-async function pathExists7(p) {
+async function pathExists5(p) {
   try {
-    await access9(p, fsConstants9.F_OK);
+    await access6(p, fsConstants6.F_OK);
     return true;
   } catch {
     return false;
@@ -8176,25 +6813,25 @@ async function pathExists7(p) {
 }
 
 // src/installers/cursor/paths.ts
-import { resolve as resolve14 } from "path";
+import { resolve as resolve12 } from "path";
 var CURSOR_RELATIVE_DIR = ".cursor";
 function cursorDir(home) {
-  return resolve14(home, CURSOR_RELATIVE_DIR);
+  return resolve12(home, CURSOR_RELATIVE_DIR);
 }
 function cursorMcpJsonPath(home) {
-  return resolve14(cursorDir(home), "mcp.json");
+  return resolve12(cursorDir(home), "mcp.json");
 }
 function cursorRulesDir(home) {
-  return resolve14(cursorDir(home), "rules");
+  return resolve12(cursorDir(home), "rules");
 }
 function cursorRuleMdcPath(home, ruleName) {
-  return resolve14(cursorRulesDir(home), `${ruleName}.mdc`);
+  return resolve12(cursorRulesDir(home), `${ruleName}.mdc`);
 }
 function cursorSkillsDir(home) {
-  return resolve14(cursorDir(home), "skills");
+  return resolve12(cursorDir(home), "skills");
 }
 function cursorSkillDir(home, skillName) {
-  return resolve14(cursorSkillsDir(home), skillName);
+  return resolve12(cursorSkillsDir(home), skillName);
 }
 function bridgeSkillFileReference(skillName) {
   return `.cursor/skills/${skillName}/SKILL.md`;
@@ -8304,13 +6941,13 @@ function quoteIfNeeded(value) {
 }
 
 // src/installers/cursor/skills.ts
-import { readFile as readFile11 } from "fs/promises";
-import { resolve as resolve15 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve13 } from "path";
 async function readSkillDescription(skillSourceDir) {
-  const skillMdPath = resolve15(skillSourceDir, "SKILL.md");
+  const skillMdPath = resolve13(skillSourceDir, "SKILL.md");
   let raw;
   try {
-    raw = await readFile11(skillMdPath, "utf8");
+    raw = await readFile8(skillMdPath, "utf8");
   } catch {
     return void 0;
   }
@@ -8340,11 +6977,11 @@ async function executeRollback(ledger) {
       if (entry.kind === "restore-file") {
         await atomicWriteFile(entry.path, entry.originalContent);
       } else if (entry.kind === "remove-file") {
-        await rm11(entry.path, { force: true });
+        await rm8(entry.path, { force: true });
       } else if (entry.kind === "remove-dir") {
-        await rm11(entry.path, { recursive: true, force: true });
+        await rm8(entry.path, { recursive: true, force: true });
       } else {
-        await rm11(entry.path, { recursive: true, force: true });
+        await rm8(entry.path, { recursive: true, force: true });
         await safeRename(entry.backupPath, entry.path);
       }
     } catch (err) {
@@ -8356,20 +6993,20 @@ async function executeRollback(ledger) {
   return errors;
 }
 async function atomicWriteFile(filePath, content) {
-  await mkdir10(dirname9(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID8()}.tmp`;
+  await mkdir7(dirname7(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID5()}.tmp`;
   try {
-    await writeFile9(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename8(tmp, filePath);
+    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename5(tmp, filePath);
   } catch (err) {
-    await rm11(tmp, { force: true }).catch(() => {
+    await rm8(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function getMcpMtimeMs(filePath) {
   try {
-    const s = await stat9(filePath);
+    const s = await stat5(filePath);
     return s.mtimeMs;
   } catch {
     return null;
@@ -8602,13 +7239,13 @@ var CursorInstaller = class {
       if (info === "missing") continue;
       if (info === "skill-dir") {
         if (!dryRun) {
-          await rm11(filePath, { recursive: true, force: true });
+          await rm8(filePath, { recursive: true, force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (info === "mdc-file") {
-        const content = await readFile12(filePath, "utf8").catch(() => "");
+        const content = await readFile9(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`
@@ -8616,13 +7253,13 @@ var CursorInstaller = class {
           continue;
         }
         if (!dryRun) {
-          await rm11(filePath, { force: true });
+          await rm8(filePath, { force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (!dryRun) {
-        await rm11(filePath, { force: true });
+        await rm8(filePath, { force: true });
       }
       removedFiles.push(filePath);
     }
@@ -8670,10 +7307,10 @@ var CursorInstaller = class {
     const prevEntry = registryStore.get(plugin.ref);
     const prevFiles = new Set(prevEntry?.targets?.cursor?.files ?? []);
     if (plugin.capabilities.includes("skills")) {
-      const skillsSourceDir = resolve16(plugin.sourceDir, "skills");
+      const skillsSourceDir = resolve14(plugin.sourceDir, "skills");
       const skillDirs = await listSkillDirs(skillsSourceDir);
       for (const skillName of skillDirs) {
-        const srcDir = resolve16(skillsSourceDir, skillName);
+        const srcDir = resolve14(skillsSourceDir, skillName);
         const destDir = cursorSkillDir(this.home, skillName);
         const bridgeRulePath = cursorRuleMdcPath(this.home, skillName);
         if (await dirExists2(destDir)) {
@@ -8705,10 +7342,10 @@ var CursorInstaller = class {
       }
     }
     if (plugin.capabilities.includes("rules")) {
-      const rulesSourceDir = resolve16(plugin.sourceDir, "rules");
+      const rulesSourceDir = resolve14(plugin.sourceDir, "rules");
       const rulesFiles = await listRuleMdFiles(rulesSourceDir);
       for (const ruleFile of rulesFiles) {
-        const srcPath = resolve16(rulesSourceDir, ruleFile);
+        const srcPath = resolve14(rulesSourceDir, ruleFile);
         const ruleName = ruleFile.replace(/\.md$/i, "");
         const destPath = cursorRuleMdcPath(this.home, ruleName);
         await assertMdcWritable(destPath, args.force);
@@ -8717,7 +7354,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 readFile12(srcPath, "utf8");
+        const src = await readFile9(srcPath, "utf8");
         const parsed = parseMarkdown(src);
         const content = renderMdc(parsed, {
           descriptionFallback: plugin.manifest.description ?? ruleName
@@ -8726,7 +7363,7 @@ var CursorInstaller = class {
         plannedFiles.push(destPath);
       }
     }
-    const mcpAdditions = extractMcpAdditions(plugin);
+    const mcpAdditions = await extractMcpAdditions(plugin);
     if (mcpAdditions && Object.keys(mcpAdditions).length > 0) {
       plannedFiles.push(cursorMcpJsonPath(this.home));
       plannedMcpKeys.push(...Object.keys(mcpAdditions));
@@ -8745,7 +7382,7 @@ var CursorInstaller = class {
   // -------------------------------------------------------------------------
   async writeSkillDir(args) {
     const preExisted = await dirExists2(args.destDir);
-    await mkdir10(dirname9(args.destDir), { recursive: true });
+    await mkdir7(dirname7(args.destDir), { recursive: true });
     if (preExisted) {
       const backup = `${args.destDir}.${process.pid}.${Date.now()}.bak`;
       await safeRename(args.destDir, backup);
@@ -8757,12 +7394,12 @@ var CursorInstaller = class {
     } else {
       args.ledger.push({ kind: "remove-dir", path: args.destDir });
     }
-    await cp3(args.srcDir, args.destDir, { recursive: true });
+    await cp2(args.srcDir, args.destDir, { recursive: true });
   }
   async writeMdcFile(args) {
     const preExisted = await fileExists(args.path);
     if (preExisted) {
-      const original = await readFile12(args.path, "utf8");
+      const original = await readFile9(args.path, "utf8");
       args.ledger.push({
         kind: "restore-file",
         path: args.path,
@@ -8776,7 +7413,7 @@ var CursorInstaller = class {
   async writeMcpMerge(args) {
     const preExisted = await fileExists(args.mcpPath);
     if (preExisted) {
-      const original = await readFile12(args.mcpPath, "utf8");
+      const original = await readFile9(args.mcpPath, "utf8");
       args.ledger.push({
         kind: "restore-file",
         path: args.mcpPath,
@@ -8860,7 +7497,7 @@ function skippedResult() {
 }
 async function assertMdcWritable(path4, force) {
   if (!await fileExists(path4)) return;
-  const raw = await readFile12(path4, "utf8").catch(() => "");
+  const raw = await readFile9(path4, "utf8").catch(() => "");
   if (hasRushAiMarker(raw)) return;
   if (force) return;
   throw new CursorInstallConflictError(
@@ -8868,12 +7505,19 @@ async function assertMdcWritable(path4, force) {
     `\u76EE\u6807 .mdc \u5DF2\u5B58\u5728\u4E14\u65E0 rush-ai marker\uFF08${path4}\uFF09\u2014\u2014\u4E0D\u8986\u76D6\u7528\u6237\u624B\u5199 rule`
   );
 }
-function extractMcpAdditions(plugin) {
+async function extractMcpAdditions(plugin) {
   const m = plugin.manifest.mcpServers;
   if (m === void 0 || m === null) return null;
-  if (typeof m === "string") return null;
+  let serverMap = null;
+  if (typeof m === "object") {
+    serverMap = m;
+  } else if (typeof m === "string") {
+    const { readExternalMcpServers: readExternalMcpServers2 } = await import("./mcp-UZYID3GG.js");
+    serverMap = await readExternalMcpServers2(plugin.sourceDir, m);
+  }
+  if (!serverMap) return null;
   const out = {};
-  for (const [key, cfg] of Object.entries(m)) {
+  for (const [key, cfg] of Object.entries(serverMap)) {
     if (cfg && typeof cfg === "object" && typeof cfg.command === "string") {
       out[key] = cfg;
     }
@@ -8882,19 +7526,19 @@ function extractMcpAdditions(plugin) {
 }
 async function listSkillDirs(skillsDir) {
   if (!await dirExists2(skillsDir)) return [];
-  const { readdir: readdir6 } = await import("fs/promises");
-  const entries = await readdir6(skillsDir, { withFileTypes: true });
+  const { readdir: readdir5 } = await import("fs/promises");
+  const entries = await readdir5(skillsDir, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => !name.startsWith(".")).sort();
 }
 async function listRuleMdFiles(rulesDir) {
   if (!await dirExists2(rulesDir)) return [];
-  const { readdir: readdir6 } = await import("fs/promises");
-  const entries = await readdir6(rulesDir, { withFileTypes: true });
+  const { readdir: readdir5 } = await import("fs/promises");
+  const entries = await readdir5(rulesDir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && /\.md$/i.test(e.name)).map((e) => e.name).sort();
 }
 async function dirExists2(p) {
   try {
-    const s = await stat9(p);
+    const s = await stat5(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -8902,21 +7546,21 @@ async function dirExists2(p) {
 }
 async function fileExists(p) {
   try {
-    await access10(p, fsConstants10.F_OK);
-    const s = await stat9(p);
+    await access7(p, fsConstants7.F_OK);
+    const s = await stat5(p);
     return s.isFile();
   } catch {
     return false;
   }
 }
 async function safeRename(from, to) {
-  const { rename: rename10 } = await import("fs/promises");
-  await rename10(from, to);
+  const { rename: rename7 } = await import("fs/promises");
+  await rename7(from, to);
 }
 async function classifyArtifactPath(p) {
   let s;
   try {
-    s = await stat9(p);
+    s = await stat5(p);
   } catch {
     return "missing";
   }
@@ -8929,22 +7573,22 @@ async function classifyArtifactPath(p) {
 }
 
 // src/migration/cleanup.ts
-import { lstat as lstat3, rm as rm12, unlink as unlink2 } from "fs/promises";
+import { lstat as lstat3, rm as rm9, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve16 } from "path";
 
 // src/migration/detect.ts
-import { access as access11, lstat as lstat2, readFile as readFile13, readlink as readlink2, stat as stat10 } from "fs/promises";
+import { access as access8, lstat as lstat2, readFile as readFile10, readlink as readlink2, stat as stat6 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { isAbsolute as isAbsolute4, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve15 } from "path";
 var LEGACY_ASSET_MANIFEST_RELATIVE = ".rush/plugins/claude-code/asset-manifest.json";
 var LEGACY_ASSETS_DIR_RELATIVE = ".rush/plugins/claude-code/assets";
 var LEGACY_CLAUDE_CODE_DIR_RELATIVE = ".rush/plugins/claude-code";
 var LEGACY_SKILL_SYMLINK_RELATIVE = ".claude/skills/rush-task";
 var CLAUDE_SETTINGS_JSON_RELATIVE = ".claude/settings.json";
-async function pathExists8(p) {
+async function pathExists6(p) {
   try {
-    await access11(p);
+    await access8(p);
     return true;
   } catch {
     return false;
@@ -8955,7 +7599,7 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
     const lst = await lstat2(linkPath);
     if (!lst.isSymbolicLink()) return false;
     const rawTarget = await readlink2(linkPath);
-    const resolvedTarget = isAbsolute4(rawTarget) ? rawTarget : resolve17(linkPath, "..", rawTarget);
+    const resolvedTarget = isAbsolute3(rawTarget) ? rawTarget : resolve15(linkPath, "..", rawTarget);
     return resolvedTarget === expectedTarget || resolvedTarget.startsWith(`${expectedTarget}/`);
   } catch {
     return false;
@@ -8963,8 +7607,8 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
 }
 async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
   try {
-    if (!await pathExists8(settingsJsonPath)) return false;
-    const raw = await readFile13(settingsJsonPath, "utf8");
+    if (!await pathExists6(settingsJsonPath)) return false;
+    const raw = await readFile10(settingsJsonPath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -8992,12 +7636,12 @@ async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
 }
 async function detectLegacyInstall(opts = {}) {
   const home = opts.home ?? homedir12();
-  const assetManifestPath = resolve17(home, LEGACY_ASSET_MANIFEST_RELATIVE);
-  const legacyAssetsDir = resolve17(home, LEGACY_ASSETS_DIR_RELATIVE);
-  const skillSymlinkPath = resolve17(home, LEGACY_SKILL_SYMLINK_RELATIVE);
-  const settingsJsonPath = resolve17(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const assetManifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const legacyAssetsDir = resolve15(home, LEGACY_ASSETS_DIR_RELATIVE);
+  const skillSymlinkPath = resolve15(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const settingsJsonPath = resolve15(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   const [hasAssetManifest, hasLegacySkillSymlink, legacyMcpWithoutEnabled] = await Promise.all([
-    pathExists8(assetManifestPath),
+    pathExists6(assetManifestPath),
     isSymlinkPointingInto(skillSymlinkPath, legacyAssetsDir),
     hasLegacyMcpWithoutEnabled(settingsJsonPath)
   ]);
@@ -9010,11 +7654,11 @@ async function detectLegacyInstall(opts = {}) {
 }
 async function detectLegacyVersion(opts = {}) {
   const home = opts.home ?? homedir12();
-  const manifestPath = resolve17(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const manifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
   try {
-    const lst = await stat10(manifestPath);
+    const lst = await stat6(manifestPath);
     if (!lst.isFile()) return "0.7.x";
-    const raw = await readFile13(manifestPath, "utf8");
+    const raw = await readFile10(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.version;
@@ -9028,9 +7672,9 @@ async function detectLegacyVersion(opts = {}) {
 
 // src/migration/cleanup.ts
 async function cleanupLegacyDir(home) {
-  const dir = resolve18(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
+  const dir = resolve16(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
   try {
-    await rm12(dir, { recursive: true, force: true });
+    await rm9(dir, { recursive: true, force: true });
     return { ok: true };
   } catch (err) {
     return {
@@ -9040,7 +7684,7 @@ async function cleanupLegacyDir(home) {
   }
 }
 async function cleanupLegacySymlink(home) {
-  const path4 = resolve18(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const path4 = resolve16(home, LEGACY_SKILL_SYMLINK_RELATIVE);
   try {
     let lst;
     try {
@@ -9062,7 +7706,7 @@ async function cleanupLegacySymlink(home) {
   }
 }
 async function cleanupLegacyMcp(home) {
-  const path4 = resolve18(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const path4 = resolve16(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   try {
     const { data, existed } = await readJsonFile(
       path4,
@@ -9118,13 +7762,13 @@ function errorMessage(err) {
 }
 
 // src/migration/log.ts
-import { appendFile as appendFile2, mkdir as mkdir11 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir8 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { dirname as dirname10, resolve as resolve19 } from "path";
+import { dirname as dirname8, resolve as resolve17 } from "path";
 var MIGRATION_LOG_RELATIVE_PATH = ".rush/plugins/migration-failed.log";
 function resolveMigrationLogPath(opts = {}) {
   const home = opts.home ?? homedir14();
-  return resolve19(home, MIGRATION_LOG_RELATIVE_PATH);
+  return resolve17(home, MIGRATION_LOG_RELATIVE_PATH);
 }
 async function appendMigrationFailure(reason, opts = {}) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -9141,31 +7785,31 @@ async function appendMigrationFailure(reason, opts = {}) {
   const payload = `${lines.join("\n")}
 `;
   try {
-    await mkdir11(dirname10(logPath), { recursive: true });
+    await mkdir8(dirname8(logPath), { recursive: true });
     await appendFile2(logPath, payload, { encoding: "utf8" });
   } catch {
   }
 }
 
 // src/migration/migrate.ts
-import { access as access14, readFile as readFile15 } from "fs/promises";
+import { access as access11, readFile as readFile12 } from "fs/promises";
 import { homedir as homedir16 } from "os";
 
 // src/plugins/resolver.ts
-import { randomUUID as randomUUID9 } from "crypto";
-import { mkdir as mkdir12, rename as rename9, rm as rm13 } from "fs/promises";
+import { randomUUID as randomUUID6 } from "crypto";
+import { mkdir as mkdir9, rename as rename6, rm as rm10 } from "fs/promises";
 import { homedir as homedir15 } from "os";
 import {
-  isAbsolute as isAbsolute5,
+  isAbsolute as isAbsolute4,
   relative as pathRelative2,
-  resolve as pathResolve3,
+  resolve as pathResolve,
   sep as pathSep
 } from "path";
 
 // src/plugins/capabilities.ts
-import { constants as fsConstants11 } from "fs";
-import { access as access12, readdir as readdir5, stat as stat11 } from "fs/promises";
-import { extname as extname2, resolve as resolve20 } from "path";
+import { constants as fsConstants8 } from "fs";
+import { access as access9, readdir as readdir4, stat as stat7 } from "fs/promises";
+import { extname as extname2, resolve as resolve18 } from "path";
 var CAPABILITY_ORDER = [
   "commands",
   "skills",
@@ -9194,20 +7838,20 @@ async function scanCapabilities(sourceDir, manifest) {
   return CAPABILITY_ORDER.filter((cap) => found.has(cap));
 }
 async function hasCommands(sourceDir) {
-  return dirHasFileWithExt(resolve20(sourceDir, "commands"), ".md");
+  return dirHasFileWithExt(resolve18(sourceDir, "commands"), ".md");
 }
 async function hasSkills(sourceDir) {
-  const skillsDir = resolve20(sourceDir, "skills");
+  const skillsDir = resolve18(sourceDir, "skills");
   if (await dirExists3(skillsDir)) {
     let entries;
     try {
-      entries = await readdir5(skillsDir, { withFileTypes: true });
+      entries = await readdir4(skillsDir, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillMdPath = resolve20(skillsDir, entry.name, "SKILL.md");
+      const skillMdPath = resolve18(skillsDir, entry.name, "SKILL.md");
       if (await fileExists2(skillMdPath)) {
         return true;
       }
@@ -9216,16 +7860,16 @@ async function hasSkills(sourceDir) {
   return hasClaudeStyleSkills(sourceDir);
 }
 async function hasRules(sourceDir) {
-  return dirHasFileWithExt(resolve20(sourceDir, "rules"), ".md");
+  return dirHasFileWithExt(resolve18(sourceDir, "rules"), ".md");
 }
 async function hasHooks(sourceDir) {
-  const hooksDir = resolve20(sourceDir, "hooks");
+  const hooksDir = resolve18(sourceDir, "hooks");
   if (!await dirExists3(hooksDir)) {
     return false;
   }
   let entries;
   try {
-    entries = await readdir5(hooksDir, { withFileTypes: true });
+    entries = await readdir4(hooksDir, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -9251,7 +7895,7 @@ async function dirHasFileWithExt(dirPath, ext) {
   }
   let entries;
   try {
-    entries = await readdir5(dirPath, { withFileTypes: true });
+    entries = await readdir4(dirPath, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -9261,19 +7905,19 @@ async function dirHasFileWithExt(dirPath, ext) {
   );
 }
 async function hasClaudeStyleSkills(sourceDir) {
-  const dotSkillsDir = resolve20(sourceDir, ".skills");
+  const dotSkillsDir = resolve18(sourceDir, ".skills");
   if (!await dirExists3(dotSkillsDir)) {
     return false;
   }
   async function walk2(dirPath) {
     let entries;
     try {
-      entries = await readdir5(dirPath, { withFileTypes: true });
+      entries = await readdir4(dirPath, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const abs = resolve20(dirPath, entry.name);
+      const abs = resolve18(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (await walk2(abs)) return true;
         continue;
@@ -9288,7 +7932,7 @@ async function hasClaudeStyleSkills(sourceDir) {
 }
 async function dirExists3(p) {
   try {
-    const s = await stat11(p);
+    const s = await stat7(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -9296,8 +7940,8 @@ async function dirExists3(p) {
 }
 async function fileExists2(p) {
   try {
-    await access12(p, fsConstants11.R_OK);
-    const s = await stat11(p);
+    await access9(p, fsConstants8.R_OK);
+    const s = await stat7(p);
     return s.isFile();
   } catch {
     return false;
@@ -9366,18 +8010,18 @@ var PluginCloneFailedError = class extends PluginResolverError {
 };
 
 // src/plugins/manifest.ts
-import { constants as fsConstants12 } from "fs";
-import { access as access13, readFile as readFile14 } from "fs/promises";
-import { resolve as resolve21 } from "path";
+import { constants as fsConstants9 } from "fs";
+import { access as access10, readFile as readFile11 } from "fs/promises";
+import { resolve as resolve19 } from "path";
 var PLUGIN_MANIFEST_RELATIVE_PATH = ".claude-plugin/plugin.json";
 async function readPluginManifest(pluginName, sourceDir) {
-  const manifestPath = resolve21(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
+  const manifestPath = resolve19(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
   try {
-    await access13(manifestPath, fsConstants12.R_OK);
+    await access10(manifestPath, fsConstants9.R_OK);
   } catch {
     throw new PluginManifestNotFoundError(pluginName, manifestPath);
   }
-  const raw = await readFile14(manifestPath, "utf8");
+  const raw = await readFile11(manifestPath, "utf8");
   return parsePluginManifest(pluginName, raw, manifestPath);
 }
 function parsePluginManifest(pluginName, raw, sourcePathForError) {
@@ -9432,10 +8076,17 @@ async function resolvePlugin(ref, marketplace, options = {}) {
   });
   const sourceDir = resolvePluginSourceDir(ref, marketplace, entry);
   const manifest = await readPluginManifest(ref.name, sourceDir);
-  const capabilities = await scanCapabilities(sourceDir, manifest);
+  const manifestWithImplicitMcp = await injectImplicitMcpRef(
+    sourceDir,
+    manifest
+  );
+  const capabilities = await scanCapabilities(
+    sourceDir,
+    manifestWithImplicitMcp
+  );
   const normalizedManifest = normalizeRushMcpCommand(
     ref,
-    manifest,
+    manifestWithImplicitMcp,
     options.rushAiBinaryResolver
   );
   return {
@@ -9463,17 +8114,17 @@ function resolvePluginSourceDir(ref, marketplace, entry) {
     return extractUrlSourceDir(marketplace, entry);
   }
   const relPath = extractRelativeSourcePath(ref, marketplace, entry);
-  if (isAbsolute5(relPath)) {
+  if (isAbsolute4(relPath)) {
     throw new PluginSourceUnresolvableError(
       ref.name,
       marketplace.name,
       `source path must be relative to marketplace root; got absolute '${relPath}'`
     );
   }
-  const rootAbs = pathResolve3(marketplace.rootDir);
-  const abs = pathResolve3(rootAbs, relPath);
+  const rootAbs = pathResolve(marketplace.rootDir);
+  const abs = pathResolve(rootAbs, relPath);
   const rel = pathRelative2(rootAbs, abs);
-  const isEscaping = rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute5(rel);
+  const isEscaping = rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute4(rel);
   if (isEscaping) {
     throw new PluginSourceUnresolvableError(
       ref.name,
@@ -9488,16 +8139,16 @@ function extractUrlSourceDir(marketplace, entry) {
   const cacheDir = pluginCacheDir(marketplace.name, entry.name);
   const subPath = typeof src.path === "string" ? src.path.trim() : "";
   if (!subPath) return cacheDir;
-  if (isAbsolute5(subPath)) {
+  if (isAbsolute4(subPath)) {
     throw new PluginSourceUnresolvableError(
       entry.name,
       marketplace.name,
       `URL source subpath must be relative; got absolute '${subPath}'`
     );
   }
-  const resolved = pathResolve3(cacheDir, subPath);
+  const resolved = pathResolve(cacheDir, subPath);
   const rel = pathRelative2(cacheDir, resolved);
-  if (rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute5(rel)) {
+  if (rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute4(rel)) {
     throw new PluginSourceUnresolvableError(
       entry.name,
       marketplace.name,
@@ -9539,6 +8190,12 @@ function extractRelativeSourcePath(ref, marketplace, entry) {
     `source field has unexpected type '${typeof entry.source}'`
   );
 }
+async function injectImplicitMcpRef(sourceDir, manifest) {
+  if (manifest.mcpServers !== void 0) return manifest;
+  const mcpJsonPath = pathResolve(sourceDir, ".mcp.json");
+  if (!await pathExists3(mcpJsonPath)) return manifest;
+  return { ...manifest, mcpServers: "./.mcp.json" };
+}
 function normalizeRushMcpCommand(ref, manifest, rushAiBinaryResolver) {
   if (ref.name !== RUSH_AI_PLUGIN_NAME3 || ref.marketplace !== RUSH_AI_MARKETPLACE_NAME3 && ref.marketplace !== RUSH_AI_MARKETPLACE_NAME_NEW2) {
     return manifest;
@@ -9555,11 +8212,11 @@ function normalizeRushMcpCommand(ref, manifest, rushAiBinaryResolver) {
   if (typeof currentCommand !== "string" || currentCommand.length === 0) {
     return manifest;
   }
-  if (isAbsolute5(currentCommand)) {
+  if (isAbsolute4(currentCommand)) {
     return manifest;
   }
   const resolved = (rushAiBinaryResolver ?? defaultRushAiBinaryResolver2)();
-  if (!resolved || !isAbsolute5(resolved)) {
+  if (!resolved || !isAbsolute4(resolved)) {
     return manifest;
   }
   const nextServers = {
@@ -9570,7 +8227,7 @@ function normalizeRushMcpCommand(ref, manifest, rushAiBinaryResolver) {
 }
 function defaultRushAiBinaryResolver2() {
   const argv1 = process.argv[1];
-  if (typeof argv1 === "string" && isAbsolute5(argv1)) {
+  if (typeof argv1 === "string" && isAbsolute4(argv1)) {
     return argv1;
   }
   return void 0;
@@ -9578,7 +8235,7 @@ function defaultRushAiBinaryResolver2() {
 function pluginCacheDir(marketplaceName, pluginName) {
   assertSafePathComponent(marketplaceName, "marketplace name");
   assertSafePathComponent(pluginName, "plugin name");
-  return pathResolve3(
+  return pathResolve(
     homedir15(),
     ".rush",
     "plugin-cache",
@@ -9604,7 +8261,7 @@ async function ensurePluginCloned(ref, marketplace, entry, opts) {
   if (!src || typeof src !== "object" || Array.isArray(src)) return;
   if (typeof src.url !== "string" || !src.url) return;
   const cacheDir = pluginCacheDir(marketplace.name, entry.name);
-  if (await pathExists5(cacheDir)) return;
+  if (await pathExists3(cacheDir)) return;
   if (opts?.dryRun) {
     throw new PluginSourceUnresolvableError(
       ref.name,
@@ -9613,9 +8270,9 @@ async function ensurePluginCloned(ref, marketplace, entry, opts) {
     );
   }
   const git = opts?.runner ?? defaultGitRunner;
-  const parent = pathResolve3(cacheDir, "..");
-  await mkdir12(parent, { recursive: true });
-  const tmpDir = `${cacheDir}.${randomUUID9()}.tmp`;
+  const parent = pathResolve(cacheDir, "..");
+  await mkdir9(parent, { recursive: true });
+  const tmpDir = `${cacheDir}.${randomUUID6()}.tmp`;
   try {
     const args = ["clone", "--depth", "1"];
     if (typeof src.ref === "string" && src.ref.length > 0) {
@@ -9641,16 +8298,16 @@ async function ensurePluginCloned(ref, marketplace, entry, opts) {
       }
     }
     try {
-      await rename9(tmpDir, cacheDir);
+      await rename6(tmpDir, cacheDir);
     } catch (err) {
-      if (err.code === "ENOTEMPTY" && await pathExists5(cacheDir)) {
-        await rm13(tmpDir, { recursive: true, force: true });
+      if (err.code === "ENOTEMPTY" && await pathExists3(cacheDir)) {
+        await rm10(tmpDir, { recursive: true, force: true });
         return;
       }
       throw err;
     }
   } catch (err) {
-    await rm13(tmpDir, { recursive: true, force: true }).catch(() => {
+    await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
     });
     if (err instanceof PluginSourceUnresolvableError) throw err;
     throw new PluginCloneFailedError(ref.name, marketplace.name, err);
@@ -9880,7 +8537,7 @@ function isTruthyEnvValue(value) {
 }
 async function verifyNewFormat(manifestPath, expectedName, _expectedVersion) {
   try {
-    await access14(manifestPath);
+    await access11(manifestPath);
   } catch (err) {
     return {
       ok: false,
@@ -9889,7 +8546,7 @@ async function verifyNewFormat(manifestPath, expectedName, _expectedVersion) {
   }
   let raw;
   try {
-    raw = await readFile15(manifestPath, "utf8");
+    raw = await readFile12(manifestPath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -10270,9 +8927,9 @@ async function runInstall(input) {
     }
   }
   if (marketplace.source.kind === "rush") {
-    const pluginDir = resolve22(marketplace.rootDir, "plugins", ref.name);
-    const manifestPath = resolve22(pluginDir, ".claude-plugin/plugin.json");
-    const alreadyMaterialized = await pathExists5(manifestPath);
+    const pluginDir = resolve20(marketplace.rootDir, "plugins", ref.name);
+    const manifestPath = resolve20(pluginDir, ".claude-plugin/plugin.json");
+    const alreadyMaterialized = await pathExists3(manifestPath);
     const hasNewSecrets = input.secrets && Object.keys(input.secrets).length > 0;
     const shouldMaterialize = !alreadyMaterialized || force || hasNewSecrets;
     if (shouldMaterialize && dryRun && !alreadyMaterialized) {
@@ -10337,7 +8994,7 @@ async function runInstall(input) {
   if (force && !dryRun) {
     const entry = marketplace.manifest.plugins.find((p) => p.name === ref.name);
     if (entry && hasUrlSource(entry)) {
-      await rm14(pluginCacheDir(ref.marketplace, ref.name), {
+      await rm11(pluginCacheDir(ref.marketplace, ref.name), {
         recursive: true,
         force: true
       });
@@ -10463,6 +9120,24 @@ async function runInstall(input) {
       registryError = formatRegistryError(err);
     }
   }
+  let codexMirrorSyncError;
+  const codexResult = results.find((r) => r.target === "codex");
+  if (!dryRun && codexResult?.status === "ok" && !skipCodexMirrorSync(input)) {
+    try {
+      const [{ syncCodexMarketplaceMirror: syncCodexMarketplaceMirror2 }, { pickContentLoader: pickContentLoader2 }] = await Promise.all([
+        import("./mirror-IHLOSPAS.js"),
+        import("./_codex-content-loader-Q7KBWZSB.js")
+      ]);
+      await syncCodexMarketplaceMirror2(input.home ?? homedir17(), marketplace, {
+        contentLoader: pickContentLoader2(marketplace)
+      });
+    } catch (err) {
+      codexMirrorSyncError = err instanceof Error ? err.message : String(err);
+      output.warn(
+        `[codex] post-install marketplace mirror sync failed: ${codexMirrorSyncError}`
+      );
+    }
+  }
   const hasFailed = results.some((r) => r.status === "failed");
   const exitCode = hasFailed ? 1 : 0;
   return {
@@ -10473,9 +9148,15 @@ async function runInstall(input) {
     dryRun,
     exitCode,
     ...registryError !== void 0 ? { registryError } : {},
+    ...codexMirrorSyncError !== void 0 ? { codexMirrorSyncError } : {},
     ...migrationOutcome !== void 0 ? { migration: migrationOutcome } : {}
   };
 }
+function skipCodexMirrorSync(input) {
+  if (input.skipCodexMirrorSync === true) return true;
+  if (input.installerFactory !== void 0) return true;
+  return false;
+}
 function formatRegistryError(err) {
   if (err instanceof RushRegistryConflictError) {
     return `rush-ai registry write conflict: ${err.message}`;
@@ -11258,7 +9939,7 @@ function getReskillInvocation() {
   };
 }
 function runReskill(args) {
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve23, reject) => {
     const reskill = getReskillInvocation();
     const child = spawn2(reskill.command, [...reskill.args, ...args], {
       env: createReskillEnv(),
@@ -11268,10 +9949,10 @@ function runReskill(args) {
     child.on("close", (code, signal) => {
       if (signal) {
         output.error(`reskill exited from signal ${signal}`);
-        resolve25(1);
+        resolve23(1);
         return;
       }
-      resolve25(code ?? 1);
+      resolve23(code ?? 1);
     });
   });
 }
@@ -11345,7 +10026,7 @@ function registerSkillCommand(program) {
 
 // src/commands/task/index.ts
 import { createWriteStream } from "fs";
-import { mkdir as mkdir13, readFile as readFile16, stat as stat12 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile13, stat as stat8 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
@@ -11371,13 +10052,13 @@ async function readStdinIfPiped() {
   if (process.stdin.isTTY) {
     return null;
   }
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve23, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
       chunks.push(chunk);
     });
     process.stdin.on("end", () => {
-      resolve25(Buffer.concat(chunks).toString("utf-8").trim());
+      resolve23(Buffer.concat(chunks).toString("utf-8").trim());
     });
     process.stdin.on("error", reject);
   });
@@ -11578,7 +10259,7 @@ function buildDeployUrl(prefix, env, apiBaseUrl) {
 }
 
 // src/commands/task/push.ts
-import { resolve as resolve23 } from "path";
+import { resolve as resolve21 } from "path";
 import chalk5 from "chalk";
 
 // src/util/env-file.ts
@@ -11722,7 +10403,7 @@ function registerPushSubcommand(task, program) {
     requireAuth();
     const format = resolveFormat(program.opts());
     const client = createClient();
-    const projectPath = resolve23(opts.path);
+    const projectPath = resolve21(opts.path);
     if (format !== "json") {
       output.info("Checking project readiness...");
     }
@@ -12153,7 +10834,7 @@ async function confirmPublish(args) {
   return answer.trim().toLowerCase().startsWith("y");
 }
 function readOneLine() {
-  return new Promise((resolve25) => {
+  return new Promise((resolve23) => {
     let acc = "";
     const onData = (chunk) => {
       acc += chunk.toString("utf-8");
@@ -12161,7 +10842,7 @@ function readOneLine() {
       if (nlIdx !== -1) {
         process.stdin.removeListener("data", onData);
         process.stdin.pause();
-        resolve25(acc.slice(0, nlIdx));
+        resolve23(acc.slice(0, nlIdx));
       }
     };
     process.stdin.resume();
@@ -12347,12 +11028,12 @@ function registerDomainSubcommand(task, program) {
 }
 
 // src/commands/task/env.ts
-import { resolve as resolve24 } from "path";
+import { resolve as resolve22 } from "path";
 
 // src/util/prompt.ts
 import { createInterface } from "readline";
 function promptSecret(message) {
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve23, reject) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -12365,7 +11046,7 @@ function promptSecret(message) {
     rl.question("", (answer) => {
       rl.close();
       process.stdout.write("\n");
-      resolve25(answer);
+      resolve23(answer);
     });
     rl.on("SIGINT", () => {
       rl.close();
@@ -12388,7 +11069,7 @@ var NO_PROJECT_HINT2 = [
 ].join("\n");
 function resolveProjectId(opts) {
   if (opts.project) return Promise.resolve(opts.project);
-  const projectPath = resolve24(opts.path ?? ".");
+  const projectPath = resolve22(opts.path ?? ".");
   const remoteUrl = isGitRepo(projectPath) ? getRemoteUrl(projectPath) : null;
   const idFromRemote = remoteUrl ? extractRushProjectId(remoteUrl) : null;
   if (idFromRemote) return Promise.resolve(idFromRemote);
@@ -13116,7 +11797,7 @@ async function downloadFile(file2, destPath, client) {
   if (!response.body) {
     throw new Error("No response body");
   }
-  await mkdir13(path3.dirname(destPath), { recursive: true });
+  await mkdir10(path3.dirname(destPath), { recursive: true });
   const nodeStream = Readable.fromWeb(
     response.body
   );
@@ -13657,7 +12338,7 @@ async function uploadFileForTask(client, localPath) {
   const resolved = path3.resolve(localPath);
   let fileStat;
   try {
-    fileStat = await stat12(resolved);
+    fileStat = await stat8(resolved);
   } catch {
     throw new RushError(`File not found: ${localPath}`);
   }
@@ -13671,7 +12352,7 @@ async function uploadFileForTask(client, localPath) {
   }
   const filename = path3.basename(resolved);
   const mediaType = guessMediaType(resolved);
-  const buf = await readFile16(resolved);
+  const buf = await readFile13(resolved);
   const blob = new File([buf], filename, { type: mediaType });
   const formData = new FormData();
   formData.append("file", blob);
@@ -13724,9 +12405,9 @@ function registerCommands(program) {
 }
 
 // src/util/update-check.ts
-import { mkdir as mkdir14, readFile as readFile17, writeFile as writeFile10 } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import { dirname as dirname11, join as join10 } from "path";
+import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname9, 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";
@@ -13749,19 +12430,19 @@ function isNewerVersion(current, latest) {
 }
 async function writeLastCheck(checkFile) {
   try {
-    await mkdir14(dirname11(checkFile), { recursive: true });
-    await writeFile10(checkFile, JSON.stringify({ lastCheck: Date.now() }));
+    await mkdir11(dirname9(checkFile), { recursive: true });
+    await writeFile7(checkFile, JSON.stringify({ lastCheck: Date.now() }));
   } catch {
   }
 }
 async function checkForUpdate(currentVersion) {
-  const rushDir = join10(homedir17(), ".rush");
+  const rushDir = join10(homedir18(), ".rush");
   const checkFile = join10(rushDir, "update-check.json");
   try {
     if (process.env.CI) return;
     let lastCheck = 0;
     try {
-      const data = JSON.parse(await readFile17(checkFile, "utf-8"));
+      const data = JSON.parse(await readFile14(checkFile, "utf-8"));
       lastCheck = data.lastCheck ?? 0;
     } catch {
     }