rush-ai 0.20.0 → 0.21.0

package/dist/index.js

@@ -32,7 +32,7 @@ import {
   fetchRushPlugin,
   materializeRushPlugin,
   pickContentLoader
-} from "./chunk-E2CKW6JZ.js";
+} from "./chunk-C7KJUHEF.js";
 import {
   consumeSSEStreamWithReconnect
 } from "./chunk-MG4HY2PD.js";
@@ -81,7 +81,7 @@ import {
   defaultRushBinaryResolver,
   normalizeClaudeMcpServers,
   readExternalMcpServers
-} from "./chunk-X45FKY3L.js";
+} from "./chunk-22YQT6XF.js";
 
 // src/index.ts
 import chalk7 from "chalk";
@@ -446,7 +446,7 @@ function getApiBaseUrl() {
 async function loginViaBrowser(jsonMode) {
   const baseUrl = getApiBaseUrl();
   const state = randomBytes(16).toString("hex");
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve25, reject) => {
     let authSaved = false;
     const rejectLogin = (error) => {
       clearAuthConfig();
@@ -549,7 +549,7 @@ async function loginViaBrowser(jsonMode) {
             );
           }
         }
-        resolve23();
+        resolve25();
       } catch (err) {
         server.close();
         const authError = err instanceof AuthError ? err : new AuthError(
@@ -3357,8 +3357,8 @@ async function writeFileAtomic(filePath, content) {
   const tmp = `${filePath}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile2(tmp, content, { encoding: "utf8", flag: "w" });
-    const { rename: rename7 } = await import("fs/promises");
-    await rename7(tmp, filePath);
+    const { rename: rename8 } = await import("fs/promises");
+    await rename8(tmp, filePath);
   } catch (err) {
     await rm(tmp, { force: true }).catch(() => {
     });
@@ -5550,34 +5550,1040 @@ function registerPlaybookCommand(program) {
 }
 
 // src/commands/plugin/install.ts
-import { rm as rm11 } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import { resolve as resolve20 } from "path";
+import { rm as rm12 } from "fs/promises";
+import { homedir as homedir18 } from "os";
+import { resolve as resolve22 } from "path";
+
+// src/installers/claude-3p/installer.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import {
+  cp as cp2,
+  mkdir as mkdir5,
+  readdir as readdir4,
+  readFile as readFile6,
+  rename as rename3,
+  rm as rm6,
+  writeFile as writeFile5
+} from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname5, join as join9, resolve as resolve11 } from "path";
+
+// src/installers/claude-3p/paths.ts
+import { readdir as readdir3, stat as stat3 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+var CLAUDE_3P_APP_DIR = "Claude-3p";
+var LOCAL_AGENT_SESSIONS_DIR = "local-agent-mode-sessions";
+var COWORK_PLUGINS_DIR = "cowork_plugins";
+var PERSONAL_ORG_UUID = "00000000-0000-4000-8000-000000000001";
+var PLUGIN_MANIFEST_RELATIVE = ".claude-plugin/plugin.json";
+var MARKETPLACE_MANIFEST_RELATIVE = ".claude-plugin/marketplace.json";
+var UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var ClaudeCpPaths = class {
+  constructor(home) {
+    this.home = home;
+  }
+  /** `<home>/Library/Application Support/Claude-3p/` */
+  get appDir() {
+    return resolve10(
+      this.home,
+      "Library",
+      "Application Support",
+      CLAUDE_3P_APP_DIR
+    );
+  }
+  /** `<appDir>/local-agent-mode-sessions/` */
+  get sessionsDir() {
+    return resolve10(this.appDir, LOCAL_AGENT_SESSIONS_DIR);
+  }
+  /** `<sessionsDir>/<account-uuid>/` */
+  accountDir(accountUuid) {
+    return resolve10(this.sessionsDir, accountUuid);
+  }
+  /** `<sessionsDir>/<account-uuid>/<org-uuid>/` */
+  orgDir(accountUuid, orgUuid) {
+    return resolve10(this.accountDir(accountUuid), orgUuid);
+  }
+  /** `<orgDir>/cowork_account_settings.json` */
+  accountSettingsJson(accountUuid, orgUuid) {
+    return resolve10(
+      this.orgDir(accountUuid, orgUuid),
+      "cowork_account_settings.json"
+    );
+  }
+  /** `<orgDir>/cowork_settings.json` */
+  coworkSettingsJson(accountUuid, orgUuid) {
+    return resolve10(this.orgDir(accountUuid, orgUuid), "cowork_settings.json");
+  }
+  /** `<orgDir>/cowork_plugins/` */
+  coworkPluginsDir(accountUuid, orgUuid) {
+    return resolve10(this.orgDir(accountUuid, orgUuid), COWORK_PLUGINS_DIR);
+  }
+  /** `<cowork_plugins>/installed_plugins.json` */
+  installedPluginsJson(accountUuid, orgUuid) {
+    return resolve10(
+      this.coworkPluginsDir(accountUuid, orgUuid),
+      "installed_plugins.json"
+    );
+  }
+  /** `<cowork_plugins>/known_marketplaces.json` */
+  knownMarketplacesJson(accountUuid, orgUuid) {
+    return resolve10(
+      this.coworkPluginsDir(accountUuid, orgUuid),
+      "known_marketplaces.json"
+    );
+  }
+  /** `<cowork_plugins>/org_uninstalled.json` */
+  orgUninstalledJson(accountUuid, orgUuid) {
+    return resolve10(
+      this.coworkPluginsDir(accountUuid, orgUuid),
+      "org_uninstalled.json"
+    );
+  }
+  /** `<cowork_plugins>/marketplaces/` */
+  marketplacesRootDir(accountUuid, orgUuid) {
+    return resolve10(this.coworkPluginsDir(accountUuid, orgUuid), "marketplaces");
+  }
+  /** `<cowork_plugins>/marketplaces/<mkt>/` */
+  marketplaceDir(accountUuid, orgUuid, marketplace) {
+    return resolve10(this.marketplacesRootDir(accountUuid, orgUuid), marketplace);
+  }
+  /** `<cowork_plugins>/marketplaces/<mkt>/.claude-plugin/marketplace.json` */
+  marketplaceManifestPath(accountUuid, orgUuid, marketplace) {
+    return resolve10(
+      this.marketplaceDir(accountUuid, orgUuid, marketplace),
+      MARKETPLACE_MANIFEST_RELATIVE
+    );
+  }
+  /** `<cowork_plugins>/marketplaces/<mkt>/<plugin>/` */
+  pluginDir(accountUuid, orgUuid, ref) {
+    return resolve10(
+      this.marketplaceDir(accountUuid, orgUuid, ref.marketplace),
+      ref.name
+    );
+  }
+  /** `<pluginDir>/.claude-plugin/plugin.json` */
+  pluginManifestPath(accountUuid, orgUuid, ref) {
+    return resolve10(
+      this.pluginDir(accountUuid, orgUuid, ref),
+      PLUGIN_MANIFEST_RELATIVE
+    );
+  }
+  /** `<pluginDir>/.mcp.json` */
+  pluginMcpJsonPath(accountUuid, orgUuid, ref) {
+    return resolve10(this.pluginDir(accountUuid, orgUuid, ref), ".mcp.json");
+  }
+  /** `<pluginDir>/<capability>/` */
+  capabilityDir(accountUuid, orgUuid, ref, capability) {
+    return resolve10(this.pluginDir(accountUuid, orgUuid, ref), capability);
+  }
+};
+function pluginKey(ref) {
+  return `${ref.name}@${ref.marketplace}`;
+}
+async function resolveClaudeCpAccount(paths, options = {}) {
+  const orgUuid = options.orgUuid ?? PERSONAL_ORG_UUID;
+  if (options.accountUuid !== void 0) {
+    if (!UUID_V4_RE.test(options.accountUuid)) return null;
+    const settingsPath = paths.accountSettingsJson(
+      options.accountUuid,
+      orgUuid
+    );
+    if (!await pathExists(settingsPath)) return null;
+    return { accountUuid: options.accountUuid, orgUuid, warnings: [] };
+  }
+  let entries;
+  try {
+    entries = await readdir3(paths.sessionsDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const accountDirs = entries.filter(
+    (entry) => entry.isDirectory() && UUID_V4_RE.test(entry.name)
+  );
+  if (accountDirs.length === 0) return null;
+  const candidates = [];
+  for (const entry of accountDirs) {
+    const settingsPath = paths.accountSettingsJson(entry.name, orgUuid);
+    if (!await pathExists(settingsPath)) continue;
+    const stats = await stat3(paths.accountDir(entry.name)).catch(() => null);
+    candidates.push({
+      accountUuid: entry.name,
+      mtimeMs: stats?.mtimeMs ?? 0
+    });
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const pick = candidates[0];
+  if (!pick) return null;
+  const warnings = candidates.length > 1 ? [
+    `Multiple Claude-3p accounts found; selected most recent account ${pick.accountUuid}. Pass accountUuid to override.`
+  ] : [];
+  return { accountUuid: pick.accountUuid, orgUuid, warnings };
+}
+
+// src/installers/claude-3p/installer.ts
+var ClaudeCpInstaller = class {
+  target = "claude-3p";
+  paths;
+  accountOptions;
+  rushBinaryResolver;
+  now;
+  marketplaceSource;
+  constructor(opts = {}) {
+    this.paths = new ClaudeCpPaths(opts.home ?? homedir10());
+    this.accountOptions = {
+      ...opts.accountUuid !== void 0 ? { accountUuid: opts.accountUuid } : {},
+      ...opts.orgUuid !== void 0 ? { orgUuid: opts.orgUuid } : {}
+    };
+    this.rushBinaryResolver = opts.rushBinaryResolver ?? defaultRushBinaryResolver;
+    this.now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    if (opts.marketplaceSource !== void 0) {
+      this.marketplaceSource = opts.marketplaceSource;
+    }
+  }
+  async detect() {
+    return await this.resolveAccount() !== null;
+  }
+  async isInstalled(ref) {
+    const account = await this.resolveAccount();
+    if (!account) return false;
+    const data = await this.readInstalledPlugins(account);
+    const entries = data.plugins[pluginKey(ref)];
+    return Array.isArray(entries) && entries.some((e) => e.scope === "user");
+  }
+  async list() {
+    const account = await this.resolveAccount();
+    if (!account) return [];
+    const data = await this.readInstalledPlugins(account);
+    const out = [];
+    for (const [key, entries] of Object.entries(data.plugins)) {
+      if (!Array.isArray(entries) || entries.length === 0) continue;
+      const ref = parsePluginKey2(key);
+      if (!ref) continue;
+      const pick = entries.find((e) => e.scope === "user") ?? entries[0];
+      if (!pick) continue;
+      out.push({
+        ref,
+        version: pick.version,
+        installedAt: pick.installedAt,
+        targets: [this.target]
+      });
+    }
+    out.sort((a, b) => {
+      const ak = pluginKey(a.ref);
+      const bk = pluginKey(b.ref);
+      return ak < bk ? -1 : ak > bk ? 1 : 0;
+    });
+    return out;
+  }
+  async install(plugin, opts = {}) {
+    const account = await this.resolveAccount();
+    if (!account) {
+      return {
+        target: this.target,
+        status: "skipped",
+        included: [],
+        skipped: [],
+        artifacts: { files: [], mcpKeys: [] }
+      };
+    }
+    const guardError = assertSafePathComponents2(plugin.ref, plugin.version);
+    if (guardError) return this.buildFailedResult(guardError);
+    if (!opts.force && !opts.dryRun) {
+      try {
+        if (await this.isAlreadyInstalledAtVersion(account, plugin)) {
+          const files = [];
+          if (await this.upsertKnownMarketplace(account, plugin.ref)) {
+            pushUnique(
+              files,
+              this.paths.knownMarketplacesJson(
+                account.accountUuid,
+                account.orgUuid
+              )
+            );
+          }
+          if (await this.enablePlugin(account, plugin.ref)) {
+            pushUnique(
+              files,
+              this.paths.coworkSettingsJson(
+                account.accountUuid,
+                account.orgUuid
+              )
+            );
+          }
+          return {
+            target: this.target,
+            status: "ok",
+            included: this.computeIncluded(plugin),
+            skipped: this.computeSkipped(plugin),
+            artifacts: { files, mcpKeys: [] },
+            ...account.warnings.length > 0 ? { notes: account.warnings } : {}
+          };
+        }
+      } catch (err) {
+        return this.buildFailedResult(err);
+      }
+    }
+    if (opts.dryRun) {
+      try {
+        const result = await this.computeDryRun(account, plugin);
+        return appendNotes(result, account.warnings);
+      } catch (err) {
+        return this.buildFailedResult(err);
+      }
+    }
+    let rollback;
+    try {
+      rollback = await this.captureRollback(account, plugin.ref);
+    } catch (err) {
+      return this.buildFailedResult(err);
+    }
+    try {
+      const writtenFiles = [];
+      const pluginDir = this.paths.pluginDir(
+        account.accountUuid,
+        account.orgUuid,
+        plugin.ref
+      );
+      await mkdir5(pluginDir, { recursive: true });
+      pushUnique(writtenFiles, pluginDir);
+      const copied = await copyPluginSourceTracked(plugin.sourceDir, pluginDir);
+      for (const file2 of copied) pushUnique(writtenFiles, file2);
+      const mcpServers = await this.resolveMcpServers(plugin);
+      const mcpKeys = mcpServers ? Object.keys(mcpServers) : [];
+      if (mcpServers && mcpKeys.length > 0) {
+        const mcpPath = this.paths.pluginMcpJsonPath(
+          account.accountUuid,
+          account.orgUuid,
+          plugin.ref
+        );
+        await writeJsonFile(mcpPath, { mcpServers });
+        pushUnique(writtenFiles, mcpPath);
+      }
+      const manifestPath = this.paths.pluginManifestPath(
+        account.accountUuid,
+        account.orgUuid,
+        plugin.ref
+      );
+      await writeJsonFile(manifestPath, buildPluginJson(plugin, mcpKeys));
+      pushUnique(writtenFiles, manifestPath);
+      const marketplaceManifestPath = this.paths.marketplaceManifestPath(
+        account.accountUuid,
+        account.orgUuid,
+        plugin.ref.marketplace
+      );
+      await writeJsonFile(
+        marketplaceManifestPath,
+        await this.buildMarketplaceManifest(plugin.ref)
+      );
+      pushUnique(writtenFiles, marketplaceManifestPath);
+      if (await this.upsertKnownMarketplace(account, plugin.ref)) {
+        pushUnique(
+          writtenFiles,
+          this.paths.knownMarketplacesJson(account.accountUuid, account.orgUuid)
+        );
+      }
+      await this.upsertInstalledPlugin(account, plugin);
+      pushUnique(
+        writtenFiles,
+        this.paths.installedPluginsJson(account.accountUuid, account.orgUuid)
+      );
+      if (await this.enablePlugin(account, plugin.ref)) {
+        pushUnique(
+          writtenFiles,
+          this.paths.coworkSettingsJson(account.accountUuid, account.orgUuid)
+        );
+      }
+      await this.finalizeRollback(rollback);
+      return {
+        target: this.target,
+        status: "ok",
+        included: this.computeIncluded(plugin),
+        skipped: this.computeSkipped(plugin),
+        artifacts: { files: writtenFiles, mcpKeys },
+        ...account.warnings.length > 0 ? { notes: account.warnings } : {}
+      };
+    } catch (err) {
+      await this.applyRollback(rollback).catch(() => {
+      });
+      return this.buildFailedResult(err);
+    }
+  }
+  async uninstall(ref, opts = {}) {
+    const account = await this.resolveAccount();
+    if (!account) {
+      return {
+        target: this.target,
+        status: "ok",
+        artifacts: { files: [], mcpKeys: [] }
+      };
+    }
+    const guardError = assertSafePathComponents2(ref, "0.0.0");
+    if (guardError) return this.buildFailedUninstallResult(guardError);
+    try {
+      const mcpKeys = await this.collectMcpKeys(account, ref);
+      const files = await this.computeUninstallFiles(account, ref);
+      if (opts.dryRun) {
+        return {
+          target: this.target,
+          status: "ok",
+          artifacts: { files, mcpKeys }
+        };
+      }
+      const touchedFiles = [];
+      const removedFromRegistry = await this.removeInstalledPlugin(
+        account,
+        ref
+      );
+      if (removedFromRegistry) {
+        pushUnique(
+          touchedFiles,
+          this.paths.installedPluginsJson(account.accountUuid, account.orgUuid)
+        );
+      }
+      if (await this.disablePlugin(account, ref)) {
+        pushUnique(
+          touchedFiles,
+          this.paths.coworkSettingsJson(account.accountUuid, account.orgUuid)
+        );
+      }
+      const pluginDir = this.paths.pluginDir(
+        account.accountUuid,
+        account.orgUuid,
+        ref
+      );
+      if (await pathExists(pluginDir)) {
+        await rm6(pluginDir, { recursive: true, force: true });
+        pushUnique(touchedFiles, pluginDir);
+      }
+      if (removedFromRegistry && !await this.marketplaceStillReferenced(account, ref.marketplace)) {
+        const marketplaceDir = this.paths.marketplaceDir(
+          account.accountUuid,
+          account.orgUuid,
+          ref.marketplace
+        );
+        await rm6(marketplaceDir, { recursive: true, force: true });
+        pushUnique(touchedFiles, marketplaceDir);
+        if (await this.removeKnownMarketplace(account, ref.marketplace)) {
+          pushUnique(
+            touchedFiles,
+            this.paths.knownMarketplacesJson(
+              account.accountUuid,
+              account.orgUuid
+            )
+          );
+        }
+      }
+      return {
+        target: this.target,
+        status: "ok",
+        artifacts: { files: touchedFiles, mcpKeys }
+      };
+    } catch (err) {
+      return this.buildFailedUninstallResult(err);
+    }
+  }
+  async resolveAccount() {
+    return resolveClaudeCpAccount(this.paths, this.accountOptions);
+  }
+  async readInstalledPlugins(account) {
+    const filePath = this.paths.installedPluginsJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    if (!await pathExists(filePath)) return { version: 2, plugins: {} };
+    const { data } = await readJsonFile(filePath, () => ({
+      version: 2,
+      plugins: {}
+    }));
+    if (data.version !== 2) {
+      throw new Error(
+        `${filePath} has unsupported version ${String(data.version)}; expected 2`
+      );
+    }
+    if (!data.plugins || typeof data.plugins !== "object" || Array.isArray(data.plugins)) {
+      throw new Error(`${filePath} has invalid plugins shape`);
+    }
+    return data;
+  }
+  async readCoworkSettings(account) {
+    const filePath = this.paths.coworkSettingsJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    if (!await pathExists(filePath)) return {};
+    const { data } = await readJsonFile(
+      filePath,
+      () => ({})
+    );
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error(`${filePath} has invalid cowork settings shape`);
+    }
+    if (data.enabledPlugins !== void 0 && (!data.enabledPlugins || typeof data.enabledPlugins !== "object" || Array.isArray(data.enabledPlugins))) {
+      throw new Error(`${filePath} has invalid enabledPlugins shape`);
+    }
+    return data;
+  }
+  async enablePlugin(account, ref) {
+    const filePath = this.paths.coworkSettingsJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    const data = await this.readCoworkSettings(account);
+    const key = pluginKey(ref);
+    if (data.enabledPlugins?.[key] === true) return false;
+    await writeJsonFile(filePath, {
+      ...data,
+      enabledPlugins: {
+        ...data.enabledPlugins ?? {},
+        [key]: true
+      }
+    });
+    return true;
+  }
+  async disablePlugin(account, ref) {
+    const filePath = this.paths.coworkSettingsJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    if (!await pathExists(filePath)) return false;
+    const data = await this.readCoworkSettings(account);
+    const key = pluginKey(ref);
+    if (data.enabledPlugins?.[key] !== true) return false;
+    const nextEnabledPlugins = { ...data.enabledPlugins };
+    delete nextEnabledPlugins[key];
+    const next = { ...data };
+    if (Object.keys(nextEnabledPlugins).length > 0) {
+      next.enabledPlugins = nextEnabledPlugins;
+    } else {
+      delete next.enabledPlugins;
+    }
+    await writeJsonFile(filePath, next);
+    return true;
+  }
+  async isAlreadyInstalledAtVersion(account, plugin) {
+    const data = await this.readInstalledPlugins(account);
+    const entries = data.plugins[pluginKey(plugin.ref)];
+    if (!Array.isArray(entries)) return false;
+    return entries.some(
+      (entry) => entry.scope === "user" && entry.version === plugin.version
+    );
+  }
+  async upsertInstalledPlugin(account, plugin) {
+    const filePath = this.paths.installedPluginsJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    const data = await this.readInstalledPlugins(account);
+    const key = pluginKey(plugin.ref);
+    const nowIso = this.now();
+    const installPath = this.paths.pluginDir(
+      account.accountUuid,
+      account.orgUuid,
+      plugin.ref
+    );
+    const entries = data.plugins[key] ?? [];
+    const existingUser = entries.find((entry) => entry.scope === "user");
+    const nextUser = {
+      scope: "user",
+      installPath,
+      version: plugin.version,
+      installedAt: existingUser?.installedAt ?? nowIso,
+      lastUpdated: nowIso
+    };
+    const nextEntries = [
+      nextUser,
+      ...entries.filter((entry) => entry.scope !== "user")
+    ];
+    data.plugins = { ...data.plugins, [key]: nextEntries };
+    await writeJsonFile(filePath, data);
+  }
+  async removeInstalledPlugin(account, ref) {
+    const filePath = this.paths.installedPluginsJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    if (!await pathExists(filePath)) return false;
+    const data = await this.readInstalledPlugins(account);
+    const key = pluginKey(ref);
+    const entries = data.plugins[key];
+    if (!Array.isArray(entries)) return false;
+    const nextEntries = entries.filter((entry) => entry.scope !== "user");
+    if (nextEntries.length === entries.length) return false;
+    if (nextEntries.length > 0) {
+      data.plugins = { ...data.plugins, [key]: nextEntries };
+    } else {
+      const nextPlugins = { ...data.plugins };
+      delete nextPlugins[key];
+      data.plugins = nextPlugins;
+    }
+    await writeJsonFile(filePath, data);
+    return true;
+  }
+  async readKnownMarketplaces(account) {
+    const filePath = this.paths.knownMarketplacesJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    if (!await pathExists(filePath)) return {};
+    const { data } = await readJsonFile(
+      filePath,
+      () => ({})
+    );
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error(`${filePath} has invalid known marketplaces shape`);
+    }
+    return data;
+  }
+  async upsertKnownMarketplace(account, ref) {
+    const filePath = this.paths.knownMarketplacesJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    const data = await this.readKnownMarketplaces(account);
+    if (Object.hasOwn(data, ref.marketplace)) return false;
+    await writeJsonFile(filePath, {
+      ...data,
+      [ref.marketplace]: this.buildKnownMarketplaceEntry(account, ref)
+    });
+    return true;
+  }
+  async removeKnownMarketplace(account, marketplace) {
+    const filePath = this.paths.knownMarketplacesJson(
+      account.accountUuid,
+      account.orgUuid
+    );
+    if (!await pathExists(filePath)) return false;
+    const data = await this.readKnownMarketplaces(account);
+    if (!Object.hasOwn(data, marketplace)) return false;
+    const next = { ...data };
+    delete next[marketplace];
+    await writeJsonFile(filePath, next);
+    return true;
+  }
+  buildKnownMarketplaceEntry(account, ref) {
+    const installLocation = this.paths.marketplaceDir(
+      account.accountUuid,
+      account.orgUuid,
+      ref.marketplace
+    );
+    return {
+      source: {
+        source: "directory",
+        path: this.marketplaceSource?.rootDir ?? installLocation
+      },
+      installLocation,
+      lastUpdated: this.now(),
+      autoUpdate: false
+    };
+  }
+  async marketplaceStillReferenced(account, marketplace) {
+    const data = await this.readInstalledPlugins(account);
+    const suffix = `@${marketplace}`;
+    return Object.entries(data.plugins).some(
+      ([key, entries]) => key.endsWith(suffix) && Array.isArray(entries) && entries.length > 0
+    );
+  }
+  async computeDryRun(account, plugin) {
+    const files = [];
+    const pluginDir = this.paths.pluginDir(
+      account.accountUuid,
+      account.orgUuid,
+      plugin.ref
+    );
+    pushUnique(files, pluginDir);
+    const planned = await listDirFilesRecursive(plugin.sourceDir, pluginDir, {
+      skipTopLevel: /* @__PURE__ */ new Set(["rules"])
+    });
+    for (const file2 of planned) pushUnique(files, file2);
+    const mcpServers = await this.resolveMcpServers(plugin);
+    const mcpKeys = mcpServers ? Object.keys(mcpServers) : [];
+    if (mcpServers && mcpKeys.length > 0) {
+      pushUnique(
+        files,
+        this.paths.pluginMcpJsonPath(
+          account.accountUuid,
+          account.orgUuid,
+          plugin.ref
+        )
+      );
+    }
+    pushUnique(
+      files,
+      this.paths.pluginManifestPath(
+        account.accountUuid,
+        account.orgUuid,
+        plugin.ref
+      )
+    );
+    pushUnique(
+      files,
+      this.paths.marketplaceManifestPath(
+        account.accountUuid,
+        account.orgUuid,
+        plugin.ref.marketplace
+      )
+    );
+    pushUnique(
+      files,
+      this.paths.knownMarketplacesJson(account.accountUuid, account.orgUuid)
+    );
+    pushUnique(
+      files,
+      this.paths.installedPluginsJson(account.accountUuid, account.orgUuid)
+    );
+    pushUnique(
+      files,
+      this.paths.coworkSettingsJson(account.accountUuid, account.orgUuid)
+    );
+    return {
+      target: this.target,
+      status: "ok",
+      included: this.computeIncluded(plugin),
+      skipped: this.computeSkipped(plugin),
+      artifacts: { files, mcpKeys }
+    };
+  }
+  async computeUninstallFiles(account, ref) {
+    const files = [];
+    const hasInstalledEntry = await this.hasInstalledPluginEntry(account, ref);
+    if (hasInstalledEntry) {
+      pushUnique(
+        files,
+        this.paths.installedPluginsJson(account.accountUuid, account.orgUuid)
+      );
+    }
+    if (await this.hasEnabledPluginEntry(account, ref)) {
+      pushUnique(
+        files,
+        this.paths.coworkSettingsJson(account.accountUuid, account.orgUuid)
+      );
+    }
+    const pluginDir = this.paths.pluginDir(
+      account.accountUuid,
+      account.orgUuid,
+      ref
+    );
+    if (await pathExists(pluginDir)) pushUnique(files, pluginDir);
+    if (hasInstalledEntry && !await this.marketplaceWouldStillBeReferencedAfterRemoval(
+      account,
+      ref.marketplace,
+      pluginKey(ref)
+    )) {
+      pushUnique(
+        files,
+        this.paths.marketplaceDir(
+          account.accountUuid,
+          account.orgUuid,
+          ref.marketplace
+        )
+      );
+      if (await this.hasKnownMarketplaceEntry(account, ref.marketplace)) {
+        pushUnique(
+          files,
+          this.paths.knownMarketplacesJson(account.accountUuid, account.orgUuid)
+        );
+      }
+    }
+    return files;
+  }
+  async hasEnabledPluginEntry(account, ref) {
+    const data = await this.readCoworkSettings(account);
+    return data.enabledPlugins?.[pluginKey(ref)] === true;
+  }
+  async hasInstalledPluginEntry(account, ref) {
+    const data = await this.readInstalledPlugins(account);
+    const entries = data.plugins[pluginKey(ref)];
+    return Array.isArray(entries) && entries.some((entry) => entry.scope === "user");
+  }
+  async hasKnownMarketplaceEntry(account, marketplace) {
+    const data = await this.readKnownMarketplaces(account);
+    return Object.hasOwn(data, marketplace);
+  }
+  async marketplaceWouldStillBeReferencedAfterRemoval(account, marketplace, removedKey) {
+    const data = await this.readInstalledPlugins(account);
+    const suffix = `@${marketplace}`;
+    for (const [key, entries] of Object.entries(data.plugins)) {
+      if (key === removedKey) continue;
+      if (key.endsWith(suffix) && Array.isArray(entries) && entries.length > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async resolveMcpServers(plugin) {
+    if (typeof plugin.manifest.mcpServers === "string") {
+      const external = await readExternalMcpServers(
+        plugin.sourceDir,
+        plugin.manifest.mcpServers
+      );
+      if (!external) return void 0;
+      return normalizeClaudeMcpServers(
+        plugin.ref,
+        { ...plugin.manifest, mcpServers: external },
+        this.rushBinaryResolver
+      );
+    }
+    return normalizeClaudeMcpServers(
+      plugin.ref,
+      plugin.manifest,
+      this.rushBinaryResolver
+    );
+  }
+  computeIncluded(plugin) {
+    return plugin.capabilities.filter((cap) => cap !== "rules");
+  }
+  computeSkipped(plugin) {
+    return plugin.capabilities.includes("rules") ? ["rules"] : [];
+  }
+  async buildMarketplaceManifest(ref) {
+    if (this.marketplaceSource) {
+      const sourceManifest = resolve11(
+        this.marketplaceSource.rootDir,
+        ".claude-plugin",
+        "marketplace.json"
+      );
+      const raw = await readFile6(sourceManifest, "utf8");
+      return JSON.parse(raw);
+    }
+    return {
+      name: ref.marketplace,
+      plugins: [{ name: ref.name, source: `./${ref.name}` }]
+    };
+  }
+  async collectMcpKeys(account, ref) {
+    const mcpPath = this.paths.pluginMcpJsonPath(
+      account.accountUuid,
+      account.orgUuid,
+      ref
+    );
+    if (!await pathExists(mcpPath)) return [];
+    try {
+      const raw = await readFile6(mcpPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+        return Object.keys(parsed.mcpServers);
+      }
+    } catch {
+      return [];
+    }
+    return [];
+  }
+  async captureRollback(account, ref) {
+    const marketplaceDir = this.paths.marketplaceDir(
+      account.accountUuid,
+      account.orgUuid,
+      ref.marketplace
+    );
+    const marketplaceDirExisted = await pathExists(marketplaceDir);
+    const pluginDir = this.paths.pluginDir(
+      account.accountUuid,
+      account.orgUuid,
+      ref
+    );
+    const files = [
+      await snapshotFile(
+        this.paths.marketplaceManifestPath(
+          account.accountUuid,
+          account.orgUuid,
+          ref.marketplace
+        )
+      ),
+      await snapshotFile(
+        this.paths.knownMarketplacesJson(account.accountUuid, account.orgUuid)
+      ),
+      await snapshotFile(
+        this.paths.installedPluginsJson(account.accountUuid, account.orgUuid)
+      ),
+      await snapshotFile(
+        this.paths.coworkSettingsJson(account.accountUuid, account.orgUuid)
+      )
+    ];
+    return {
+      pluginDir: await moveDirAside(pluginDir),
+      marketplaceDir,
+      marketplaceDirExisted,
+      files
+    };
+  }
+  async finalizeRollback(snapshot) {
+    if (snapshot.pluginDir.backupPath) {
+      await rm6(snapshot.pluginDir.backupPath, { recursive: true, force: true });
+    }
+  }
+  async applyRollback(snapshot) {
+    await restoreMovedDir(snapshot.pluginDir);
+    for (const file2 of snapshot.files) {
+      await restoreFile(file2);
+    }
+    if (!snapshot.marketplaceDirExisted) {
+      await rm6(snapshot.marketplaceDir, { recursive: true, force: true });
+    }
+  }
+  buildFailedResult(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      target: this.target,
+      status: "failed",
+      included: [],
+      skipped: [],
+      artifacts: { files: [], mcpKeys: [] },
+      errors: [message]
+    };
+  }
+  buildFailedUninstallResult(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      target: this.target,
+      status: "failed",
+      artifacts: { files: [], mcpKeys: [] },
+      errors: [message]
+    };
+  }
+};
+function buildPluginJson(plugin, mcpKeys) {
+  const { mcpServers: _mcpServers, ...rest } = plugin.manifest;
+  return {
+    ...rest,
+    name: plugin.ref.name,
+    version: plugin.version,
+    ...mcpKeys.length > 0 ? { mcpServers: "./.mcp.json" } : {}
+  };
+}
+function appendNotes(result, notes) {
+  if (notes.length === 0) return result;
+  return { ...result, notes: [...result.notes ?? [], ...notes] };
+}
+function parsePluginKey2(key) {
+  const at = key.lastIndexOf("@");
+  if (at <= 0 || at === key.length - 1) return null;
+  return { name: key.slice(0, at), marketplace: key.slice(at + 1) };
+}
+function assertSafePathComponents2(ref, version) {
+  for (const [label, value] of [
+    ["plugin name", ref.name],
+    ["marketplace", ref.marketplace],
+    ["version", version]
+  ]) {
+    if (value.length === 0 || value === "." || value === ".." || value.includes("/") || value.includes("\\")) {
+      return new Error(`Invalid ${label} '${value}' for Claude-3p path`);
+    }
+  }
+  return null;
+}
+async function snapshotFile(path4) {
+  if (!await pathExists(path4)) return { path: path4, existed: false, content: null };
+  return { path: path4, existed: true, content: await readFile6(path4, "utf8") };
+}
+async function restoreFile(snapshot) {
+  if (snapshot.existed) {
+    await writeTextFileAtomic(snapshot.path, snapshot.content ?? "");
+    return;
+  }
+  await rm6(snapshot.path, { force: true });
+  await pruneEmptyParents(dirname5(snapshot.path), 2);
+}
+async function moveDirAside(path4) {
+  if (!await pathExists(path4)) {
+    return { path: path4, existed: false, backupPath: null };
+  }
+  const backupPath = `${path4}.rush-ai-backup-${randomUUID3()}`;
+  await rename3(path4, backupPath);
+  return { path: path4, existed: true, backupPath };
+}
+async function restoreMovedDir(snapshot) {
+  await rm6(snapshot.path, { recursive: true, force: true });
+  if (snapshot.backupPath) {
+    await rename3(snapshot.backupPath, snapshot.path);
+  }
+}
+async function copyPluginSourceTracked(srcDir, dstDir) {
+  await mkdir5(dstDir, { recursive: true });
+  await cp2(srcDir, dstDir, { recursive: true, force: true });
+  await rm6(join9(dstDir, "rules"), { recursive: true, force: true });
+  return listExistingDirPaths(dstDir);
+}
+async function listDirFilesRecursive(srcDir, dstDir, opts = {}) {
+  const out = [dstDir];
+  async function walk2(src, dst, depth) {
+    const entries = await readdir4(src, { withFileTypes: true });
+    for (const entry of entries) {
+      if (depth === 0 && opts.skipTopLevel?.has(entry.name)) continue;
+      const srcPath = join9(src, entry.name);
+      const dstPath = join9(dst, entry.name);
+      out.push(dstPath);
+      if (entry.isDirectory()) await walk2(srcPath, dstPath, depth + 1);
+    }
+  }
+  await walk2(srcDir, dstDir, 0);
+  return out;
+}
+async function listExistingDirPaths(dir) {
+  const out = [dir];
+  async function walk2(current) {
+    const entries = await readdir4(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const p = join9(current, entry.name);
+      out.push(p);
+      if (entry.isDirectory()) await walk2(p);
+    }
+  }
+  await walk2(dir);
+  return out;
+}
+async function pruneEmptyParents(startDir, maxDepth) {
+  let current = startDir;
+  for (let i = 0; i < maxDepth; i++) {
+    try {
+      const entries = await readdir4(current);
+      if (entries.length > 0) return;
+      await rm6(current, { recursive: false, force: true });
+      current = dirname5(current);
+    } catch {
+      return;
+    }
+  }
+}
+function pushUnique(list, value) {
+  if (!list.includes(value)) list.push(value);
+}
+async function writeTextFileAtomic(path4, content) {
+  await mkdir5(dirname5(path4), { recursive: true });
+  const tmp = `${path4}.${randomUUID3()}.tmp`;
+  try {
+    await writeFile5(tmp, content, "utf8");
+    await rename3(tmp, path4);
+  } catch (err) {
+    await rm6(tmp, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
 
 // src/installers/claude-code/installer.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import {
   copyFile,
   lstat,
-  mkdir as mkdir5,
-  readdir as readdir3,
-  readFile as readFile6,
+  mkdir as mkdir6,
+  readdir as readdir5,
+  readFile as readFile7,
   readlink,
-  rename as rename3,
-  rm as rm6,
-  stat as stat3,
+  rename as rename4,
+  rm as rm7,
+  stat as stat4,
   symlink,
   unlink
 } from "fs/promises";
-import { homedir as homedir10 } from "os";
-import { dirname as dirname5, join as join9, resolve as resolve11 } from "path";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname6, join as join10, resolve as resolve13 } from "path";
 
 // src/installers/claude-code/paths.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve12 } from "path";
 var CLAUDE_DIR = ".claude";
 var PLUGINS_SUBDIR = "plugins";
 var CACHE_SUBDIR = "cache";
-var PLUGIN_MANIFEST_RELATIVE = ".claude-plugin/plugin.json";
+var PLUGIN_MANIFEST_RELATIVE2 = ".claude-plugin/plugin.json";
 var CAPABILITY_DIRS = [
   "commands",
   "skills",
@@ -5591,27 +6597,27 @@ var ClaudeCodePaths = class {
   }
   /** `<home>/.claude/` */
   get claudeDir() {
-    return resolve10(this.home, CLAUDE_DIR);
+    return resolve12(this.home, CLAUDE_DIR);
   }
   /** `<home>/.claude/settings.json` */
   get settingsJson() {
-    return resolve10(this.claudeDir, "settings.json");
+    return resolve12(this.claudeDir, "settings.json");
   }
   /** `<home>/.claude/plugins/` */
   get pluginsDir() {
-    return resolve10(this.claudeDir, PLUGINS_SUBDIR);
+    return resolve12(this.claudeDir, PLUGINS_SUBDIR);
   }
   /** `<home>/.claude/plugins/known_marketplaces.json` */
   get knownMarketplacesJson() {
-    return resolve10(this.pluginsDir, "known_marketplaces.json");
+    return resolve12(this.pluginsDir, "known_marketplaces.json");
   }
   /** `<home>/.claude/plugins/installed_plugins.json` */
   get installedPluginsJson() {
-    return resolve10(this.pluginsDir, "installed_plugins.json");
+    return resolve12(this.pluginsDir, "installed_plugins.json");
   }
   /** `<home>/.claude/plugins/cache/` */
   get cacheDir() {
-    return resolve10(this.pluginsDir, CACHE_SUBDIR);
+    return resolve12(this.pluginsDir, CACHE_SUBDIR);
   }
   /**
    * `<home>/.claude/plugins/marketplaces/`。
@@ -5621,37 +6627,37 @@ var ClaudeCodePaths = class {
    * Claude Code 会识别不到 plugin 条目（regression fix，bug #4）。
    */
   get marketplacesRootDir() {
-    return resolve10(this.pluginsDir, "marketplaces");
+    return resolve12(this.pluginsDir, "marketplaces");
   }
   /** `<home>/.claude/plugins/marketplaces/<mkt>/` */
   marketplaceInstallDir(marketplace) {
-    return resolve10(this.marketplacesRootDir, marketplace);
+    return resolve12(this.marketplacesRootDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/` */
   marketplaceCacheDir(marketplace) {
-    return resolve10(this.cacheDir, marketplace);
+    return resolve12(this.cacheDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/` */
   pluginCacheDir(ref) {
-    return resolve10(this.marketplaceCacheDir(ref.marketplace), ref.name);
+    return resolve12(this.marketplaceCacheDir(ref.marketplace), ref.name);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/` */
   pluginVersionDir(ref, version) {
-    return resolve10(this.pluginCacheDir(ref), version);
+    return resolve12(this.pluginCacheDir(ref), version);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/.claude-plugin/plugin.json` */
   pluginManifestPath(ref, version) {
-    return resolve10(
+    return resolve12(
       this.pluginVersionDir(ref, version),
-      PLUGIN_MANIFEST_RELATIVE
+      PLUGIN_MANIFEST_RELATIVE2
     );
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/<capability>/` */
   capabilityDir(ref, version, capability) {
-    return resolve10(this.pluginVersionDir(ref, version), capability);
+    return resolve12(this.pluginVersionDir(ref, version), capability);
   }
 };
-function pluginKey(ref) {
+function pluginKey2(ref) {
   return `${ref.name}@${ref.marketplace}`;
 }
 
@@ -5664,7 +6670,7 @@ var ClaudeCodeInstaller = class {
   marketplaceSource;
   symlinkRunner;
   constructor(opts = {}) {
-    const home = opts.home ?? homedir10();
+    const home = opts.home ?? homedir11();
     this.paths = new ClaudeCodePaths(home);
     this.rushBinaryResolver = opts.rushBinaryResolver ?? defaultRushBinaryResolver;
     this.now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -5687,7 +6693,7 @@ var ClaudeCodeInstaller = class {
       this.paths.installedPluginsJson,
       () => ({ version: 2, plugins: {} })
     );
-    const entries = data.plugins?.[pluginKey(ref)];
+    const entries = data.plugins?.[pluginKey2(ref)];
     return Array.isArray(entries) && entries.length > 0;
   }
   async list() {
@@ -5701,7 +6707,7 @@ var ClaudeCodeInstaller = class {
     const out = [];
     for (const [key, scopeEntries] of Object.entries(data.plugins ?? {})) {
       if (!Array.isArray(scopeEntries) || scopeEntries.length === 0) continue;
-      const ref = parsePluginKey2(key);
+      const ref = parsePluginKey3(key);
       if (!ref) continue;
       const pick = scopeEntries.find((e) => e.scope === "user") ?? scopeEntries[0];
       if (!pick) continue;
@@ -5729,7 +6735,7 @@ var ClaudeCodeInstaller = class {
     }
     const { ref, version } = plugin;
     const pluginVersionDir = this.paths.pluginVersionDir(ref, version);
-    const key = pluginKey(ref);
+    const key = pluginKey2(ref);
     if (!opts.force && version !== "unknown") {
       let already = false;
       try {
@@ -5762,13 +6768,13 @@ var ClaudeCodeInstaller = class {
     }
     try {
       const writtenFiles = [];
-      await mkdir5(pluginVersionDir, { recursive: true });
+      await mkdir6(pluginVersionDir, { recursive: true });
       writtenFiles.push(pluginVersionDir);
       for (const cap of CAPABILITY_DIRS) {
-        const srcDir = resolve11(plugin.sourceDir, cap);
+        const srcDir = resolve13(plugin.sourceDir, cap);
         if (!await dirExists(srcDir)) continue;
         const dstDir = this.paths.capabilityDir(ref, version, cap);
-        await mkdir5(dstDir, { recursive: true });
+        await mkdir6(dstDir, { recursive: true });
         writtenFiles.push(dstDir);
         const copied = await copyDirTracked(srcDir, dstDir);
         writtenFiles.push(...copied);
@@ -5780,11 +6786,11 @@ var ClaudeCodeInstaller = class {
         this.rushBinaryResolver
       );
       if (normalizedMcp && Object.keys(normalizedMcp).length > 0) {
-        const mcpJsonPath = resolve11(pluginVersionDir, ".mcp.json");
+        const mcpJsonPath = resolve13(pluginVersionDir, ".mcp.json");
         await writeJsonFile(mcpJsonPath, { mcpServers: normalizedMcp });
         writtenFiles.push(mcpJsonPath);
       }
-      const pluginJsonContent = buildPluginJson(plugin, normalizedMcp);
+      const pluginJsonContent = buildPluginJson2(plugin, normalizedMcp);
       await writeJsonFile(manifestPath, pluginJsonContent);
       writtenFiles.push(manifestPath);
       const mcpKeys = normalizedMcp ? Object.keys(normalizedMcp) : [];
@@ -5849,7 +6855,7 @@ var ClaudeCodeInstaller = class {
         artifacts: { files: [], mcpKeys: [] }
       };
     }
-    const key = pluginKey(ref);
+    const key = pluginKey2(ref);
     const touchedFiles = [];
     const installedMcpKeys = await this.collectMcpKeysFromInstalled(ref);
     if (opts.dryRun) {
@@ -5908,8 +6914,8 @@ var ClaudeCodeInstaller = class {
       await unlink(mktDir);
       files.push(mktDir);
     } else if (kind === "dir") {
-      if (await pathExists(join9(mktDir, ".rush-marketplace-source.json"))) {
-        await rm6(mktDir, { recursive: true, force: true });
+      if (await pathExists(join10(mktDir, ".rush-marketplace-source.json"))) {
+        await rm7(mktDir, { recursive: true, force: true });
         files.push(mktDir);
       }
     }
@@ -5980,12 +6986,12 @@ var ClaudeCodeInstaller = class {
       return { written: false, path: "" };
     }
     const mktDir = this.paths.marketplaceInstallDir(marketplaceName);
-    await mkdir5(this.paths.marketplacesRootDir, { recursive: true });
+    await mkdir6(this.paths.marketplacesRootDir, { recursive: true });
     const kind = await inodeKind(mktDir);
     if (kind === "symlink") {
       const target = await readlink(mktDir).catch(() => null);
-      const resolvedTarget = target !== null ? resolve11(dirname5(mktDir), target) : null;
-      if (resolvedTarget && resolvedTarget === resolve11(src.rootDir)) {
+      const resolvedTarget = target !== null ? resolve13(dirname6(mktDir), target) : null;
+      if (resolvedTarget && resolvedTarget === resolve13(src.rootDir)) {
         return { written: false, path: mktDir };
       }
       throw new Error(
@@ -5993,7 +6999,7 @@ var ClaudeCodeInstaller = class {
       );
     }
     if (kind === "dir") {
-      const metaPath = join9(mktDir, ".rush-marketplace-source.json");
+      const metaPath = join10(mktDir, ".rush-marketplace-source.json");
       if (await pathExists(metaPath)) {
         const metaSourceRaw = await readMarketplaceCacheSource(metaPath);
         const currentSourceRaw = descriptorToSourceRaw(src.descriptor);
@@ -6018,7 +7024,7 @@ var ClaudeCodeInstaller = class {
       return { written: true, path: mktDir };
     }
     await copyDirTracked(src.rootDir, mktDir).catch(async (err) => {
-      await rm6(mktDir, { recursive: true, force: true }).catch(() => {
+      await rm7(mktDir, { recursive: true, force: true }).catch(() => {
       });
       throw err;
     });
@@ -6045,7 +7051,7 @@ var ClaudeCodeInstaller = class {
       this.paths.installedPluginsJson,
       () => ({ version: 2, plugins: {} })
     );
-    const entries = data.plugins?.[pluginKey(ref)];
+    const entries = data.plugins?.[pluginKey2(ref)];
     if (!Array.isArray(entries)) return false;
     return entries.some((e) => e.scope === "user" && e.version === version);
   }
@@ -6054,11 +7060,11 @@ var ClaudeCodeInstaller = class {
     const pluginVersionDir = this.paths.pluginVersionDir(ref, version);
     const dryFiles = [pluginVersionDir];
     for (const cap of CAPABILITY_DIRS) {
-      const srcDir = resolve11(plugin.sourceDir, cap);
+      const srcDir = resolve13(plugin.sourceDir, cap);
       if (!await dirExists(srcDir)) continue;
       const dstDir = this.paths.capabilityDir(ref, version, cap);
       dryFiles.push(dstDir);
-      const plannedFiles = await listDirFilesRecursive(srcDir, dstDir);
+      const plannedFiles = await listDirFilesRecursive2(srcDir, dstDir);
       dryFiles.push(...plannedFiles);
     }
     dryFiles.push(this.paths.pluginManifestPath(ref, version));
@@ -6068,7 +7074,7 @@ var ClaudeCodeInstaller = class {
       this.rushBinaryResolver
     );
     if (normalizedMcpDry && Object.keys(normalizedMcpDry).length > 0) {
-      dryFiles.push(resolve11(pluginVersionDir, ".mcp.json"));
+      dryFiles.push(resolve13(pluginVersionDir, ".mcp.json"));
     }
     if (this.marketplaceSource) {
       const mktInstallDir = this.paths.marketplaceInstallDir(ref.marketplace);
@@ -6082,7 +7088,7 @@ var ClaudeCodeInstaller = class {
     if (await this.wouldInstalledPluginsChange(ref, version, pluginVersionDir)) {
       dryFiles.push(this.paths.installedPluginsJson);
     }
-    if (await this.wouldSettingsChange(pluginKey(ref))) {
+    if (await this.wouldSettingsChange(pluginKey2(ref))) {
       dryFiles.push(this.paths.settingsJson);
     }
     const normalizedMcp = await resolveClaudeMcpServers(
@@ -6117,7 +7123,7 @@ var ClaudeCodeInstaller = class {
       this.paths.installedPluginsJson,
       () => ({ version: 2, plugins: {} })
     );
-    const key = pluginKey(ref);
+    const key = pluginKey2(ref);
     const entries = data.plugins?.[key] ?? [];
     const userEntry = entries.find((e) => e.scope === "user");
     if (!userEntry) return true;
@@ -6182,8 +7188,8 @@ var ClaudeCodeInstaller = class {
     const settings = await this.readRawJsonForRollback(this.paths.settingsJson);
     let backupVersionDir = null;
     if (preexistedVersion === "dir") {
-      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID3()}`;
-      await rename3(pluginVersionDir, backupVersionDir);
+      backupVersionDir = `${pluginVersionDir}.rollback-${randomUUID4()}`;
+      await rename4(pluginVersionDir, backupVersionDir);
     }
     return {
       ref,
@@ -6204,7 +7210,7 @@ var ClaudeCodeInstaller = class {
    */
   async finalizeRollback(snap) {
     if (snap.backupVersionDir) {
-      await rm6(snap.backupVersionDir, { recursive: true, force: true });
+      await rm7(snap.backupVersionDir, { recursive: true, force: true });
     }
   }
   /**
@@ -6217,19 +7223,19 @@ var ClaudeCodeInstaller = class {
    */
   async applyRollback(snap) {
     if (snap.preexistedVersion === "dir" && snap.backupVersionDir) {
-      await rm6(snap.pluginVersionDir, { recursive: true, force: true });
-      await rename3(snap.backupVersionDir, snap.pluginVersionDir);
+      await rm7(snap.pluginVersionDir, { recursive: true, force: true });
+      await rename4(snap.backupVersionDir, snap.pluginVersionDir);
     } else if (snap.preexistedVersion === "missing") {
-      await rm6(snap.pluginVersionDir, { recursive: true, force: true });
+      await rm7(snap.pluginVersionDir, { recursive: true, force: true });
     }
     if (snap.preexistedPlugin === "missing") {
-      await rm6(this.paths.pluginCacheDir(snap.ref), {
+      await rm7(this.paths.pluginCacheDir(snap.ref), {
         recursive: true,
         force: true
       });
     }
     if (snap.preexistedMarketplace === "missing") {
-      await rm6(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
+      await rm7(this.paths.marketplaceCacheDir(snap.ref.marketplace), {
         recursive: true,
         force: true
       });
@@ -6243,7 +7249,7 @@ var ClaudeCodeInstaller = class {
         await unlink(mktInstallDir).catch(() => {
         });
       } else if (currentKind !== "missing") {
-        await rm6(mktInstallDir, { recursive: true, force: true }).catch(
+        await rm7(mktInstallDir, { recursive: true, force: true }).catch(
           () => {
           }
         );
@@ -6266,7 +7272,7 @@ var ClaudeCodeInstaller = class {
   async restoreRawJson(path4, state) {
     if (!state.existed) {
       if (await pathExists(path4)) {
-        await rm6(path4, { force: true });
+        await rm7(path4, { force: true });
       }
       return;
     }
@@ -6361,7 +7367,7 @@ var ClaudeCodeInstaller = class {
         this.paths.installedPluginsJson,
         () => ({ version: 2, plugins: {} })
       );
-      const key = pluginKey(ref);
+      const key = pluginKey2(ref);
       const now = this.now();
       const existingEntries = data.plugins?.[key] ?? [];
       const userIdx = existingEntries.findIndex((e) => e.scope === "user");
@@ -6435,7 +7441,7 @@ var ClaudeCodeInstaller = class {
         this.paths.installedPluginsJson,
         () => ({ version: 2, plugins: {} })
       );
-      const key = pluginKey(ref);
+      const key = pluginKey2(ref);
       const existingEntries = data.plugins?.[key];
       if (!Array.isArray(existingEntries) || existingEntries.length === 0) {
         return false;
@@ -6490,7 +7496,7 @@ var ClaudeCodeInstaller = class {
       this.paths.installedPluginsJson,
       () => ({ version: 2, plugins: {} })
     );
-    const entries = data.plugins?.[pluginKey(ref)];
+    const entries = data.plugins?.[pluginKey2(ref)];
     if (!Array.isArray(entries) || entries.length === 0) return false;
     return entries.some((e) => e.scope === "user");
   }
@@ -6518,7 +7524,7 @@ var ClaudeCodeInstaller = class {
     );
     const servers = data.mcpServers;
     if (typeof servers === "string") {
-      const mcpJsonPath = resolve11(dirname5(manifestPath), "..", servers);
+      const mcpJsonPath = resolve13(dirname6(manifestPath), "..", servers);
       if (!await pathExists(mcpJsonPath)) return [];
       const { data: mcpData } = await readJsonFile(
         mcpJsonPath,
@@ -6543,11 +7549,11 @@ var ClaudeCodeInstaller = class {
       this.paths.installedPluginsJson,
       () => ({ version: 2, plugins: {} })
     );
-    const entries = data.plugins?.[pluginKey(ref)];
+    const entries = data.plugins?.[pluginKey2(ref)];
     if (!Array.isArray(entries) || entries.length === 0) return null;
     const userEntry = entries.find((e) => e.scope === "user") ?? entries[0];
     if (!userEntry) return null;
-    const manifestPath = join9(
+    const manifestPath = join10(
       userEntry.installPath,
       ".claude-plugin",
       "plugin.json"
@@ -6558,7 +7564,7 @@ var ClaudeCodeInstaller = class {
     return null;
   }
 };
-function parsePluginKey2(key) {
+function parsePluginKey3(key) {
   const at = key.indexOf("@");
   if (at <= 0 || at === key.length - 1) return null;
   return { name: key.slice(0, at), marketplace: key.slice(at + 1) };
@@ -6580,7 +7586,7 @@ async function resolveClaudeMcpServers(ref, plugin, rushBinaryResolver) {
   }
   return void 0;
 }
-function buildPluginJson(plugin, mcpServers) {
+function buildPluginJson2(plugin, mcpServers) {
   const { manifest } = plugin;
   const {
     mcpServers: _origMcp,
@@ -6596,7 +7602,7 @@ function buildPluginJson(plugin, mcpServers) {
 }
 async function readMarketplaceCacheSource(metaPath) {
   try {
-    const raw = await readFile6(metaPath, "utf8");
+    const raw = await readFile7(metaPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const sourceRaw = parsed.sourceRaw;
@@ -6631,7 +7637,7 @@ async function defaultSymlinkRunner(target, linkPath) {
 }
 async function dirExists(p) {
   try {
-    const s = await stat3(p);
+    const s = await stat4(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -6648,15 +7654,15 @@ async function inodeKind(p) {
     return "missing";
   }
 }
-async function listDirFilesRecursive(srcDir, dstDir) {
+async function listDirFilesRecursive2(srcDir, dstDir) {
   const planned = [];
-  const entries = await readdir3(srcDir, { withFileTypes: true });
+  const entries = await readdir5(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join9(srcDir, entry.name);
-    const dstPath = join9(dstDir, entry.name);
+    const srcPath = join10(srcDir, entry.name);
+    const dstPath = join10(dstDir, entry.name);
     if (entry.isDirectory()) {
       planned.push(dstPath);
-      const sub = await listDirFilesRecursive(srcPath, dstPath);
+      const sub = await listDirFilesRecursive2(srcPath, dstPath);
       planned.push(...sub);
     } else if (entry.isFile()) {
       planned.push(dstPath);
@@ -6666,17 +7672,17 @@ async function listDirFilesRecursive(srcDir, dstDir) {
 }
 async function copyDirTracked(srcDir, dstDir) {
   const written = [];
-  const entries = await readdir3(srcDir, { withFileTypes: true });
+  const entries = await readdir5(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join9(srcDir, entry.name);
-    const dstPath = join9(dstDir, entry.name);
+    const srcPath = join10(srcDir, entry.name);
+    const dstPath = join10(dstDir, entry.name);
     if (entry.isDirectory()) {
-      await mkdir5(dstPath, { recursive: true });
+      await mkdir6(dstPath, { recursive: true });
       written.push(dstPath);
       const subWritten = await copyDirTracked(srcPath, dstPath);
       written.push(...subWritten);
     } else if (entry.isFile()) {
-      await mkdir5(dirname5(dstPath), { recursive: true });
+      await mkdir6(dirname6(dstPath), { recursive: true });
       await copyFile(srcPath, dstPath);
       written.push(dstPath);
     }
@@ -6687,7 +7693,7 @@ async function writeAtomicWithMtimeCheck(filePath, data, expectedMtimeMs) {
   if (expectedMtimeMs !== null) {
     let currentMtime = null;
     try {
-      const s = await stat3(filePath);
+      const s = await stat4(filePath);
       currentMtime = s.mtimeMs;
     } catch {
       currentMtime = null;
@@ -6710,20 +7716,20 @@ async function retryOnConflict(fn) {
 }
 
 // src/installers/cursor/installer.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { constants as fsConstants7 } from "fs";
 import {
   access as access7,
-  cp as cp2,
-  mkdir as mkdir7,
-  readFile as readFile9,
-  rename as rename5,
-  rm as rm8,
-  stat as stat5,
-  writeFile as writeFile6
+  cp as cp3,
+  mkdir as mkdir8,
+  readFile as readFile10,
+  rename as rename6,
+  rm as rm9,
+  stat as stat6,
+  writeFile as writeFile7
 } from "fs/promises";
-import { homedir as homedir11 } from "os";
-import { dirname as dirname7, relative, resolve as resolve14 } from "path";
+import { homedir as homedir12 } from "os";
+import { dirname as dirname8, relative, resolve as resolve16 } from "path";
 
 // src/installers/cursor/marker.ts
 var RUSH_AI_MARKER = "<!-- rush-ai:auto-generated -->";
@@ -6732,18 +7738,18 @@ function hasRushAiMarker(fileContent) {
 }
 
 // src/installers/cursor/mcp.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { constants as fsConstants6 } from "fs";
 import {
   access as access6,
-  mkdir as mkdir6,
-  readFile as readFile7,
-  rename as rename4,
-  rm as rm7,
-  stat as stat4,
-  writeFile as writeFile5
+  mkdir as mkdir7,
+  readFile as readFile8,
+  rename as rename5,
+  rm as rm8,
+  stat as stat5,
+  writeFile as writeFile6
 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 async function readCursorMcpJson(filePath) {
   return (await readCursorMcpJsonWithMtime(filePath)).data;
 }
@@ -6751,8 +7757,8 @@ async function readCursorMcpJsonWithMtime(filePath) {
   if (!await pathExists5(filePath)) {
     return { data: {}, mtimeMs: null };
   }
-  const stats = await stat4(filePath);
-  const raw = await readFile7(filePath, "utf8");
+  const stats = await stat5(filePath);
+  const raw = await readFile8(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -6781,10 +7787,16 @@ function mergeMcpServers(current, additions) {
     cloned.mcpServers = {};
   }
   for (const [key, config] of Object.entries(additions)) {
-    cloned.mcpServers[key] = toCursorStdioEntry(config);
+    cloned.mcpServers[key] = toCursorMcpEntry(config);
   }
   return cloned;
 }
+function toCursorMcpEntry(config) {
+  if (typeof config.command === "string") {
+    return toCursorStdioEntry({ ...config, command: config.command });
+  }
+  return toCursorRemoteOrUnknownEntry(config);
+}
 function toCursorStdioEntry(config) {
   const entry = {
     type: "stdio",
@@ -6793,7 +7805,7 @@ function toCursorStdioEntry(config) {
   if (config.args !== void 0) entry.args = [...config.args];
   if (config.env !== void 0) entry.env = { ...config.env };
   if (config.cwd !== void 0) entry.cwd = config.cwd;
-  const handledKeys = /* @__PURE__ */ new Set(["command", "args", "env", "cwd"]);
+  const handledKeys = /* @__PURE__ */ new Set(["type", "command", "args", "env", "cwd"]);
   const raw = config;
   for (const [key, value] of Object.entries(raw)) {
     if (handledKeys.has(key)) continue;
@@ -6802,6 +7814,18 @@ function toCursorStdioEntry(config) {
   }
   return entry;
 }
+function toCursorRemoteOrUnknownEntry(config) {
+  const entry = {};
+  const raw = config;
+  for (const [key, value] of Object.entries(raw)) {
+    if (value === void 0) continue;
+    entry[key] = deepCopyPrimitive(value);
+  }
+  if (typeof config.url === "string" && config.url.length > 0 && typeof config.type !== "string") {
+    entry.type = "http";
+  }
+  return entry;
+}
 function deepCopyPrimitive(v) {
   if (v === null || typeof v !== "object") return v;
   try {
@@ -6819,15 +7843,15 @@ function removeMcpServers(current, keysToRemove) {
   return cloned;
 }
 async function writeCursorMcpJson(filePath, data) {
-  await mkdir6(dirname6(filePath), { recursive: true });
+  await mkdir7(dirname7(filePath), { recursive: true });
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  const tmp = `${filePath}.${randomUUID4()}.tmp`;
+  const tmp = `${filePath}.${randomUUID5()}.tmp`;
   try {
-    await writeFile5(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename4(tmp, filePath);
+    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename5(tmp, filePath);
   } catch (err) {
-    await rm7(tmp, { force: true }).catch(() => {
+    await rm8(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -6842,25 +7866,25 @@ async function pathExists5(p) {
 }
 
 // src/installers/cursor/paths.ts
-import { resolve as resolve12 } from "path";
+import { resolve as resolve14 } from "path";
 var CURSOR_RELATIVE_DIR = ".cursor";
 function cursorDir(home) {
-  return resolve12(home, CURSOR_RELATIVE_DIR);
+  return resolve14(home, CURSOR_RELATIVE_DIR);
 }
 function cursorMcpJsonPath(home) {
-  return resolve12(cursorDir(home), "mcp.json");
+  return resolve14(cursorDir(home), "mcp.json");
 }
 function cursorRulesDir(home) {
-  return resolve12(cursorDir(home), "rules");
+  return resolve14(cursorDir(home), "rules");
 }
 function cursorRuleMdcPath(home, ruleName) {
-  return resolve12(cursorRulesDir(home), `${ruleName}.mdc`);
+  return resolve14(cursorRulesDir(home), `${ruleName}.mdc`);
 }
 function cursorSkillsDir(home) {
-  return resolve12(cursorDir(home), "skills");
+  return resolve14(cursorDir(home), "skills");
 }
 function cursorSkillDir(home, skillName) {
-  return resolve12(cursorSkillsDir(home), skillName);
+  return resolve14(cursorSkillsDir(home), skillName);
 }
 function bridgeSkillFileReference(skillName) {
   return `.cursor/skills/${skillName}/SKILL.md`;
@@ -6970,13 +7994,13 @@ function quoteIfNeeded(value) {
 }
 
 // src/installers/cursor/skills.ts
-import { readFile as readFile8 } from "fs/promises";
-import { resolve as resolve13 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { resolve as resolve15 } from "path";
 async function readSkillDescription(skillSourceDir) {
-  const skillMdPath = resolve13(skillSourceDir, "SKILL.md");
+  const skillMdPath = resolve15(skillSourceDir, "SKILL.md");
   let raw;
   try {
-    raw = await readFile8(skillMdPath, "utf8");
+    raw = await readFile9(skillMdPath, "utf8");
   } catch {
     return void 0;
   }
@@ -7006,11 +8030,11 @@ async function executeRollback(ledger) {
       if (entry.kind === "restore-file") {
         await atomicWriteFile(entry.path, entry.originalContent);
       } else if (entry.kind === "remove-file") {
-        await rm8(entry.path, { force: true });
+        await rm9(entry.path, { force: true });
       } else if (entry.kind === "remove-dir") {
-        await rm8(entry.path, { recursive: true, force: true });
+        await rm9(entry.path, { recursive: true, force: true });
       } else {
-        await rm8(entry.path, { recursive: true, force: true });
+        await rm9(entry.path, { recursive: true, force: true });
         await safeRename(entry.backupPath, entry.path);
       }
     } catch (err) {
@@ -7022,20 +8046,20 @@ async function executeRollback(ledger) {
   return errors;
 }
 async function atomicWriteFile(filePath, content) {
-  await mkdir7(dirname7(filePath), { recursive: true });
-  const tmp = `${filePath}.${randomUUID5()}.tmp`;
+  await mkdir8(dirname8(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID6()}.tmp`;
   try {
-    await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
-    await rename5(tmp, filePath);
+    await writeFile7(tmp, content, { encoding: "utf8", flag: "w" });
+    await rename6(tmp, filePath);
   } catch (err) {
-    await rm8(tmp, { force: true }).catch(() => {
+    await rm9(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
 }
 async function getMcpMtimeMs(filePath) {
   try {
-    const s = await stat5(filePath);
+    const s = await stat6(filePath);
     return s.mtimeMs;
   } catch {
     return null;
@@ -7068,7 +8092,7 @@ var CursorInstaller = class {
   target = "cursor";
   home;
   constructor(options = {}) {
-    this.home = options.home ?? homedir11();
+    this.home = options.home ?? homedir12();
   }
   // -------------------------------------------------------------------------
   // PluginInstaller 接口
@@ -7268,13 +8292,13 @@ var CursorInstaller = class {
       if (info === "missing") continue;
       if (info === "skill-dir") {
         if (!dryRun) {
-          await rm8(filePath, { recursive: true, force: true });
+          await rm9(filePath, { recursive: true, force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (info === "mdc-file") {
-        const content = await readFile9(filePath, "utf8").catch(() => "");
+        const content = await readFile10(filePath, "utf8").catch(() => "");
         if (!hasRushAiMarker(content)) {
           warnings.push(
             `${filePath} \u5DF2\u88AB\u4FEE\u6539\uFF08marker \u4E22\u5931\uFF09\uFF0C\u8DF3\u8FC7\u4E0D\u52A8\u2014\u2014\u8BF7\u7528\u6237\u624B\u52A8\u5904\u7406`
@@ -7282,13 +8306,13 @@ var CursorInstaller = class {
           continue;
         }
         if (!dryRun) {
-          await rm8(filePath, { force: true });
+          await rm9(filePath, { force: true });
         }
         removedFiles.push(filePath);
         continue;
       }
       if (!dryRun) {
-        await rm8(filePath, { force: true });
+        await rm9(filePath, { force: true });
       }
       removedFiles.push(filePath);
     }
@@ -7336,10 +8360,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 = resolve14(plugin.sourceDir, "skills");
+      const skillsSourceDir = resolve16(plugin.sourceDir, "skills");
       const skillDirs = await listSkillDirs(skillsSourceDir);
       for (const skillName of skillDirs) {
-        const srcDir = resolve14(skillsSourceDir, skillName);
+        const srcDir = resolve16(skillsSourceDir, skillName);
         const destDir = cursorSkillDir(this.home, skillName);
         const bridgeRulePath = cursorRuleMdcPath(this.home, skillName);
         if (await dirExists2(destDir)) {
@@ -7371,10 +8395,10 @@ var CursorInstaller = class {
       }
     }
     if (plugin.capabilities.includes("rules")) {
-      const rulesSourceDir = resolve14(plugin.sourceDir, "rules");
+      const rulesSourceDir = resolve16(plugin.sourceDir, "rules");
       const rulesFiles = await listRuleMdFiles(rulesSourceDir);
       for (const ruleFile of rulesFiles) {
-        const srcPath = resolve14(rulesSourceDir, ruleFile);
+        const srcPath = resolve16(rulesSourceDir, ruleFile);
         const ruleName = ruleFile.replace(/\.md$/i, "");
         const destPath = cursorRuleMdcPath(this.home, ruleName);
         await assertMdcWritable(destPath, args.force);
@@ -7383,7 +8407,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 readFile9(srcPath, "utf8");
+        const src = await readFile10(srcPath, "utf8");
         const parsed = parseMarkdown(src);
         const content = renderMdc(parsed, {
           descriptionFallback: plugin.manifest.description ?? ruleName
@@ -7411,7 +8435,7 @@ var CursorInstaller = class {
   // -------------------------------------------------------------------------
   async writeSkillDir(args) {
     const preExisted = await dirExists2(args.destDir);
-    await mkdir7(dirname7(args.destDir), { recursive: true });
+    await mkdir8(dirname8(args.destDir), { recursive: true });
     if (preExisted) {
       const backup = `${args.destDir}.${process.pid}.${Date.now()}.bak`;
       await safeRename(args.destDir, backup);
@@ -7423,12 +8447,12 @@ var CursorInstaller = class {
     } else {
       args.ledger.push({ kind: "remove-dir", path: args.destDir });
     }
-    await cp2(args.srcDir, args.destDir, { recursive: true });
+    await cp3(args.srcDir, args.destDir, { recursive: true });
   }
   async writeMdcFile(args) {
     const preExisted = await fileExists(args.path);
     if (preExisted) {
-      const original = await readFile9(args.path, "utf8");
+      const original = await readFile10(args.path, "utf8");
       args.ledger.push({
         kind: "restore-file",
         path: args.path,
@@ -7442,7 +8466,7 @@ var CursorInstaller = class {
   async writeMcpMerge(args) {
     const preExisted = await fileExists(args.mcpPath);
     if (preExisted) {
-      const original = await readFile9(args.mcpPath, "utf8");
+      const original = await readFile10(args.mcpPath, "utf8");
       args.ledger.push({
         kind: "restore-file",
         path: args.mcpPath,
@@ -7526,7 +8550,7 @@ function skippedResult() {
 }
 async function assertMdcWritable(path4, force) {
   if (!await fileExists(path4)) return;
-  const raw = await readFile9(path4, "utf8").catch(() => "");
+  const raw = await readFile10(path4, "utf8").catch(() => "");
   if (hasRushAiMarker(raw)) return;
   if (force) return;
   throw new CursorInstallConflictError(
@@ -7541,7 +8565,7 @@ async function extractMcpAdditions(plugin) {
   if (typeof m === "object") {
     serverMap = m;
   } else if (typeof m === "string") {
-    const { readExternalMcpServers: readExternalMcpServers2 } = await import("./mcp-UZYID3GG.js");
+    const { readExternalMcpServers: readExternalMcpServers2 } = await import("./mcp-TROKQRBF.js");
     serverMap = await readExternalMcpServers2(plugin.sourceDir, m);
   }
   if (!serverMap) return null;
@@ -7555,19 +8579,19 @@ async function extractMcpAdditions(plugin) {
 }
 async function listSkillDirs(skillsDir) {
   if (!await dirExists2(skillsDir)) return [];
-  const { readdir: readdir5 } = await import("fs/promises");
-  const entries = await readdir5(skillsDir, { withFileTypes: true });
+  const { readdir: readdir7 } = await import("fs/promises");
+  const entries = await readdir7(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: readdir5 } = await import("fs/promises");
-  const entries = await readdir5(rulesDir, { withFileTypes: true });
+  const { readdir: readdir7 } = await import("fs/promises");
+  const entries = await readdir7(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 stat5(p);
+    const s = await stat6(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -7576,20 +8600,20 @@ async function dirExists2(p) {
 async function fileExists(p) {
   try {
     await access7(p, fsConstants7.F_OK);
-    const s = await stat5(p);
+    const s = await stat6(p);
     return s.isFile();
   } catch {
     return false;
   }
 }
 async function safeRename(from, to) {
-  const { rename: rename7 } = await import("fs/promises");
-  await rename7(from, to);
+  const { rename: rename8 } = await import("fs/promises");
+  await rename8(from, to);
 }
 async function classifyArtifactPath(p) {
   let s;
   try {
-    s = await stat5(p);
+    s = await stat6(p);
   } catch {
     return "missing";
   }
@@ -7602,14 +8626,14 @@ async function classifyArtifactPath(p) {
 }
 
 // src/migration/cleanup.ts
-import { lstat as lstat3, rm as rm9, unlink as unlink2 } from "fs/promises";
-import { homedir as homedir13 } from "os";
-import { resolve as resolve16 } from "path";
+import { lstat as lstat3, rm as rm10, unlink as unlink2 } from "fs/promises";
+import { homedir as homedir14 } from "os";
+import { resolve as resolve18 } from "path";
 
 // src/migration/detect.ts
-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 isAbsolute3, resolve as resolve15 } from "path";
+import { access as access8, lstat as lstat2, readFile as readFile11, readlink as readlink2, stat as stat7 } from "fs/promises";
+import { homedir as homedir13 } from "os";
+import { isAbsolute as isAbsolute3, resolve as resolve17 } 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";
@@ -7628,7 +8652,7 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
     const lst = await lstat2(linkPath);
     if (!lst.isSymbolicLink()) return false;
     const rawTarget = await readlink2(linkPath);
-    const resolvedTarget = isAbsolute3(rawTarget) ? rawTarget : resolve15(linkPath, "..", rawTarget);
+    const resolvedTarget = isAbsolute3(rawTarget) ? rawTarget : resolve17(linkPath, "..", rawTarget);
     return resolvedTarget === expectedTarget || resolvedTarget.startsWith(`${expectedTarget}/`);
   } catch {
     return false;
@@ -7637,7 +8661,7 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
 async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
   try {
     if (!await pathExists6(settingsJsonPath)) return false;
-    const raw = await readFile10(settingsJsonPath, "utf8");
+    const raw = await readFile11(settingsJsonPath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -7664,11 +8688,11 @@ async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
   }
 }
 async function detectLegacyInstall(opts = {}) {
-  const home = opts.home ?? homedir12();
-  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 home = opts.home ?? homedir13();
+  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 [hasAssetManifest, hasLegacySkillSymlink, legacyMcpWithoutEnabled] = await Promise.all([
     pathExists6(assetManifestPath),
     isSymlinkPointingInto(skillSymlinkPath, legacyAssetsDir),
@@ -7682,12 +8706,12 @@ async function detectLegacyInstall(opts = {}) {
   };
 }
 async function detectLegacyVersion(opts = {}) {
-  const home = opts.home ?? homedir12();
-  const manifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const home = opts.home ?? homedir13();
+  const manifestPath = resolve17(home, LEGACY_ASSET_MANIFEST_RELATIVE);
   try {
-    const lst = await stat6(manifestPath);
+    const lst = await stat7(manifestPath);
     if (!lst.isFile()) return "0.7.x";
-    const raw = await readFile10(manifestPath, "utf8");
+    const raw = await readFile11(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.version;
@@ -7701,9 +8725,9 @@ async function detectLegacyVersion(opts = {}) {
 
 // src/migration/cleanup.ts
 async function cleanupLegacyDir(home) {
-  const dir = resolve16(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
+  const dir = resolve18(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
   try {
-    await rm9(dir, { recursive: true, force: true });
+    await rm10(dir, { recursive: true, force: true });
     return { ok: true };
   } catch (err) {
     return {
@@ -7713,7 +8737,7 @@ async function cleanupLegacyDir(home) {
   }
 }
 async function cleanupLegacySymlink(home) {
-  const path4 = resolve16(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const path4 = resolve18(home, LEGACY_SKILL_SYMLINK_RELATIVE);
   try {
     let lst;
     try {
@@ -7735,7 +8759,7 @@ async function cleanupLegacySymlink(home) {
   }
 }
 async function cleanupLegacyMcp(home) {
-  const path4 = resolve16(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const path4 = resolve18(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   try {
     const { data, existed } = await readJsonFile(
       path4,
@@ -7763,7 +8787,7 @@ async function cleanupLegacyMcp(home) {
   }
 }
 async function cleanupLegacyInstall(opts = {}) {
-  const home = opts.home ?? homedir13();
+  const home = opts.home ?? homedir14();
   const legacyDir = await cleanupLegacyDir(home);
   const skillSymlink = await cleanupLegacySymlink(home);
   const settingsMcp = await cleanupLegacyMcp(home);
@@ -7791,13 +8815,13 @@ function errorMessage(err) {
 }
 
 // src/migration/log.ts
-import { appendFile as appendFile2, mkdir as mkdir8 } from "fs/promises";
-import { homedir as homedir14 } from "os";
-import { dirname as dirname8, resolve as resolve17 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir9 } from "fs/promises";
+import { homedir as homedir15 } from "os";
+import { dirname as dirname9, resolve as resolve19 } from "path";
 var MIGRATION_LOG_RELATIVE_PATH = ".rush/plugins/migration-failed.log";
 function resolveMigrationLogPath(opts = {}) {
-  const home = opts.home ?? homedir14();
-  return resolve17(home, MIGRATION_LOG_RELATIVE_PATH);
+  const home = opts.home ?? homedir15();
+  return resolve19(home, MIGRATION_LOG_RELATIVE_PATH);
 }
 async function appendMigrationFailure(reason, opts = {}) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -7814,20 +8838,20 @@ async function appendMigrationFailure(reason, opts = {}) {
   const payload = `${lines.join("\n")}
 `;
   try {
-    await mkdir8(dirname8(logPath), { recursive: true });
+    await mkdir9(dirname9(logPath), { recursive: true });
     await appendFile2(logPath, payload, { encoding: "utf8" });
   } catch {
   }
 }
 
 // src/migration/migrate.ts
-import { access as access11, readFile as readFile12 } from "fs/promises";
-import { homedir as homedir16 } from "os";
+import { access as access11, readFile as readFile13 } from "fs/promises";
+import { homedir as homedir17 } from "os";
 
 // src/plugins/resolver.ts
-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 { randomUUID as randomUUID7 } from "crypto";
+import { mkdir as mkdir10, rename as rename7, rm as rm11 } from "fs/promises";
+import { homedir as homedir16 } from "os";
 import {
   isAbsolute as isAbsolute4,
   relative as pathRelative2,
@@ -7837,8 +8861,8 @@ import {
 
 // src/plugins/capabilities.ts
 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";
+import { access as access9, readdir as readdir6, stat as stat8 } from "fs/promises";
+import { extname as extname2, resolve as resolve20 } from "path";
 var CAPABILITY_ORDER = [
   "commands",
   "skills",
@@ -7867,20 +8891,20 @@ async function scanCapabilities(sourceDir, manifest) {
   return CAPABILITY_ORDER.filter((cap) => found.has(cap));
 }
 async function hasCommands(sourceDir) {
-  return dirHasFileWithExt(resolve18(sourceDir, "commands"), ".md");
+  return dirHasFileWithExt(resolve20(sourceDir, "commands"), ".md");
 }
 async function hasSkills(sourceDir) {
-  const skillsDir = resolve18(sourceDir, "skills");
+  const skillsDir = resolve20(sourceDir, "skills");
   if (await dirExists3(skillsDir)) {
     let entries;
     try {
-      entries = await readdir4(skillsDir, { withFileTypes: true });
+      entries = await readdir6(skillsDir, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillMdPath = resolve18(skillsDir, entry.name, "SKILL.md");
+      const skillMdPath = resolve20(skillsDir, entry.name, "SKILL.md");
       if (await fileExists2(skillMdPath)) {
         return true;
       }
@@ -7889,16 +8913,16 @@ async function hasSkills(sourceDir) {
   return hasClaudeStyleSkills(sourceDir);
 }
 async function hasRules(sourceDir) {
-  return dirHasFileWithExt(resolve18(sourceDir, "rules"), ".md");
+  return dirHasFileWithExt(resolve20(sourceDir, "rules"), ".md");
 }
 async function hasHooks(sourceDir) {
-  const hooksDir = resolve18(sourceDir, "hooks");
+  const hooksDir = resolve20(sourceDir, "hooks");
   if (!await dirExists3(hooksDir)) {
     return false;
   }
   let entries;
   try {
-    entries = await readdir4(hooksDir, { withFileTypes: true });
+    entries = await readdir6(hooksDir, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -7924,7 +8948,7 @@ async function dirHasFileWithExt(dirPath, ext) {
   }
   let entries;
   try {
-    entries = await readdir4(dirPath, { withFileTypes: true });
+    entries = await readdir6(dirPath, { withFileTypes: true });
   } catch {
     return false;
   }
@@ -7934,19 +8958,19 @@ async function dirHasFileWithExt(dirPath, ext) {
   );
 }
 async function hasClaudeStyleSkills(sourceDir) {
-  const dotSkillsDir = resolve18(sourceDir, ".skills");
+  const dotSkillsDir = resolve20(sourceDir, ".skills");
   if (!await dirExists3(dotSkillsDir)) {
     return false;
   }
   async function walk2(dirPath) {
     let entries;
     try {
-      entries = await readdir4(dirPath, { withFileTypes: true });
+      entries = await readdir6(dirPath, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const abs = resolve18(dirPath, entry.name);
+      const abs = resolve20(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (await walk2(abs)) return true;
         continue;
@@ -7961,7 +8985,7 @@ async function hasClaudeStyleSkills(sourceDir) {
 }
 async function dirExists3(p) {
   try {
-    const s = await stat7(p);
+    const s = await stat8(p);
     return s.isDirectory();
   } catch {
     return false;
@@ -7970,7 +8994,7 @@ async function dirExists3(p) {
 async function fileExists2(p) {
   try {
     await access9(p, fsConstants8.R_OK);
-    const s = await stat7(p);
+    const s = await stat8(p);
     return s.isFile();
   } catch {
     return false;
@@ -8040,17 +9064,17 @@ var PluginCloneFailedError = class extends PluginResolverError {
 
 // src/plugins/manifest.ts
 import { constants as fsConstants9 } from "fs";
-import { access as access10, readFile as readFile11 } from "fs/promises";
-import { resolve as resolve19 } from "path";
+import { access as access10, readFile as readFile12 } from "fs/promises";
+import { resolve as resolve21 } from "path";
 var PLUGIN_MANIFEST_RELATIVE_PATH = ".claude-plugin/plugin.json";
 async function readPluginManifest(pluginName, sourceDir) {
-  const manifestPath = resolve19(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
+  const manifestPath = resolve21(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
   try {
     await access10(manifestPath, fsConstants9.R_OK);
   } catch {
     throw new PluginManifestNotFoundError(pluginName, manifestPath);
   }
-  const raw = await readFile11(manifestPath, "utf8");
+  const raw = await readFile12(manifestPath, "utf8");
   return parsePluginManifest(pluginName, raw, manifestPath);
 }
 function parsePluginManifest(pluginName, raw, sourcePathForError) {
@@ -8265,7 +9289,7 @@ function pluginCacheDir(marketplaceName, pluginName) {
   assertSafePathComponent(marketplaceName, "marketplace name");
   assertSafePathComponent(pluginName, "plugin name");
   return pathResolve(
-    homedir15(),
+    homedir16(),
     ".rush",
     "plugin-cache",
     marketplaceName,
@@ -8300,8 +9324,8 @@ async function ensurePluginCloned(ref, marketplace, entry, opts) {
   }
   const git = opts?.runner ?? defaultGitRunner;
   const parent = pathResolve(cacheDir, "..");
-  await mkdir9(parent, { recursive: true });
-  const tmpDir = `${cacheDir}.${randomUUID6()}.tmp`;
+  await mkdir10(parent, { recursive: true });
+  const tmpDir = `${cacheDir}.${randomUUID7()}.tmp`;
   try {
     const args = ["clone", "--depth", "1"];
     if (typeof src.ref === "string" && src.ref.length > 0) {
@@ -8327,16 +9351,16 @@ async function ensurePluginCloned(ref, marketplace, entry, opts) {
       }
     }
     try {
-      await rename6(tmpDir, cacheDir);
+      await rename7(tmpDir, cacheDir);
     } catch (err) {
       if (err.code === "ENOTEMPTY" && await pathExists3(cacheDir)) {
-        await rm10(tmpDir, { recursive: true, force: true });
+        await rm11(tmpDir, { recursive: true, force: true });
         return;
       }
       throw err;
     }
   } catch (err) {
-    await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
+    await rm11(tmpDir, { recursive: true, force: true }).catch(() => {
     });
     if (err instanceof PluginSourceUnresolvableError) throw err;
     throw new PluginCloneFailedError(ref.name, marketplace.name, err);
@@ -8347,7 +9371,7 @@ async function ensurePluginCloned(ref, marketplace, entry, opts) {
 var LEGACY_MIGRATION_KEY = "legacy-rush-0.7.x";
 var SKIP_MIGRATION_ENV = "RUSH_SKIP_MIGRATION";
 async function maybeRunMigration(input) {
-  const home = input.home ?? homedir16();
+  const home = input.home ?? homedir17();
   const now = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const envGet = input.env ?? ((key) => process.env[key]);
   const reporter = input.reporter ?? {};
@@ -8575,7 +9599,7 @@ async function verifyNewFormat(manifestPath, expectedName, _expectedVersion) {
   }
   let raw;
   try {
-    raw = await readFile12(manifestPath, "utf8");
+    raw = await readFile13(manifestPath, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -8651,18 +9675,22 @@ var DEFAULT_TARGETS2 = [
   "codex",
   "cursor"
 ];
-var VALID_TARGETS = new Set(DEFAULT_TARGETS2);
-function parseTargets2(raw) {
+var VALID_TARGETS = [
+  ...DEFAULT_TARGETS2,
+  "claude-3p"
+];
+var VALID_TARGET_SET = new Set(VALID_TARGETS);
+function parseTargets2(raw, defaultTargets = DEFAULT_TARGETS2) {
   if (raw === void 0 || raw.trim().length === 0) {
-    return [...DEFAULT_TARGETS2];
+    return [...defaultTargets];
   }
   const segments = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const seg of segments) {
-    if (!VALID_TARGETS.has(seg)) {
+    if (!VALID_TARGET_SET.has(seg)) {
       throw new RushError(
-        `Invalid --target '${seg}'. Expected one of: ${[...DEFAULT_TARGETS2].join(", ")}`,
+        `Invalid --target '${seg}'. Expected one of: ${[...VALID_TARGETS].join(", ")}`,
         { raw: seg },
         "INVALID_TARGET",
         2
@@ -8675,10 +9703,60 @@ function parseTargets2(raw) {
     }
   }
   if (out.length === 0) {
-    return [...DEFAULT_TARGETS2];
+    return [...defaultTargets];
+  }
+  return out;
+}
+function maintenanceTargetsFromRegistry(registry) {
+  const installedTargets = [];
+  for (const [, entry] of registry.list()) {
+    for (const target of Object.keys(entry.targets)) {
+      if (isInstallTarget(target)) installedTargets.push(target);
+    }
+  }
+  return mergeTargets(DEFAULT_TARGETS2, installedTargets);
+}
+function maintenanceTargetsForRef(registry, ref) {
+  const entry = registry.get(ref);
+  if (!entry) return [...DEFAULT_TARGETS2];
+  const installedTargets = Object.keys(entry.targets).filter(isInstallTarget);
+  return installedTargets.length > 0 ? installedTargets : [...DEFAULT_TARGETS2];
+}
+function claude3pAccountFromRegistryEntry(entry) {
+  const claude3p = entry?.targets["claude-3p"];
+  if (!claude3p) return void 0;
+  for (const file2 of claude3p.files) {
+    const parsed = parseClaude3pAccountFromPath(file2);
+    if (parsed) return parsed;
+  }
+  return void 0;
+}
+function parseClaude3pAccountFromPath(filePath) {
+  const parts = filePath.split(/[\\/]+/).filter(Boolean);
+  const sessionsIdx = parts.lastIndexOf(LOCAL_AGENT_SESSIONS_DIR);
+  if (sessionsIdx < 0) return void 0;
+  const accountUuid = parts[sessionsIdx + 1];
+  const orgUuid = parts[sessionsIdx + 2];
+  const coworkSegment = parts[sessionsIdx + 3];
+  if (accountUuid === void 0 || orgUuid === void 0 || coworkSegment !== COWORK_PLUGINS_DIR || !UUID_V4_RE.test(accountUuid) || !UUID_V4_RE.test(orgUuid)) {
+    return void 0;
+  }
+  return { accountUuid, orgUuid };
+}
+function mergeTargets(fallback, extra) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of [...fallback, ...extra]) {
+    if (!seen.has(target)) {
+      seen.add(target);
+      out.push(target);
+    }
   }
   return out;
 }
+function isInstallTarget(value) {
+  return VALID_TARGET_SET.has(value);
+}
 async function parsePluginRef(raw, cache) {
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
@@ -8785,6 +9863,20 @@ function defaultInstallerFactory(target, opts = {}) {
       };
       return new CodexInstaller(cxOpts);
     }
+    case "claude-3p": {
+      const cpOpts = {};
+      if (opts.home !== void 0) cpOpts.home = opts.home;
+      if (opts.claude3pAccount?.accountUuid !== void 0) {
+        cpOpts.accountUuid = opts.claude3pAccount.accountUuid;
+      }
+      if (opts.claude3pAccount?.orgUuid !== void 0) {
+        cpOpts.orgUuid = opts.claude3pAccount.orgUuid;
+      }
+      if (opts.claude3pMarketplaceSource !== void 0) {
+        cpOpts.marketplaceSource = opts.claude3pMarketplaceSource;
+      }
+      return new ClaudeCpInstaller(cpOpts);
+    }
     default: {
       const _exhaustive = target;
       void _exhaustive;
@@ -8842,6 +9934,9 @@ function claudeMarketplaceSourceFrom(marketplace) {
       return void 0;
   }
 }
+function claude3pMarketplaceSourceFrom(marketplace) {
+  return { rootDir: marketplace.rootDir };
+}
 function buildRegistryEntry(plugin, results, nowIso) {
   const nonSkipped = results.filter((r) => r.status !== "skipped");
   if (nonSkipped.length === 0) {
@@ -8908,7 +10003,11 @@ async function runInstall(input) {
   const dryRun = input.dryRun === true;
   const now = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const cache = input.cache ?? new MarketplaceCache(input.home !== void 0 ? { home: input.home } : {});
+  output.dim(`  Resolving plugin reference: ${input.ref}`);
   const ref = await parsePluginRef(input.ref, cache);
+  output.dim(
+    `  Loading marketplace '${ref.marketplace}' for plugin '${ref.name}'`
+  );
   let marketplace;
   try {
     marketplace = await cache.get(ref.marketplace);
@@ -8916,6 +10015,7 @@ async function runInstall(input) {
     if (err instanceof MarketplaceNotFoundError) {
       if (ref.marketplace === "rush" || ref.marketplace === "rush-marketplace") {
         const apiHost = getGlobalConfig().api.replace(/^https?:\/\//, "");
+        output.dim(`  Registering Rush marketplace from ${apiHost}`);
         const rushSource = parseSource(`rush://${apiHost}`);
         await cache.add(rushSource, { as: ref.marketplace });
         marketplace = await cache.get(ref.marketplace);
@@ -8949,6 +10049,7 @@ Try:
     const cacheEntry = cacheList.find((m) => m.name === ref.marketplace);
     const isStale = cacheEntry?.cachedAt ? Date.now() - new Date(cacheEntry.cachedAt).getTime() > TWENTY_FOUR_HOURS : false;
     if (entryMissing || isStale) {
+      output.dim(`  Refreshing marketplace '${ref.marketplace}'`);
       marketplace = await cache.update(ref.marketplace);
     }
     if (!marketplace.manifest.plugins.some((p) => p.name === ref.name)) {
@@ -8961,8 +10062,8 @@ Try:
     }
   }
   if (marketplace.source.kind === "rush") {
-    const pluginDir = resolve20(marketplace.rootDir, "plugins", ref.name);
-    const manifestPath = resolve20(pluginDir, ".claude-plugin/plugin.json");
+    const pluginDir = resolve22(marketplace.rootDir, "plugins", ref.name);
+    const manifestPath = resolve22(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;
@@ -8977,6 +10078,7 @@ Try:
     if (shouldMaterialize && !dryRun) {
       const rushSource = marketplace.source;
       const token = getAuthToken();
+      output.dim(`  Fetching plugin manifest: ${ref.name}@${ref.marketplace}`);
       let apiManifest;
       try {
         apiManifest = await fetchRushPlugin(rushSource, ref.name, { token });
@@ -9008,6 +10110,9 @@ Try:
         secrets = { ...prompted, ...presetSecrets };
       }
       try {
+        output.dim(
+          `  Downloading plugin assets: ${ref.name}@${ref.marketplace}`
+        );
         await materializeRushPlugin(rushSource, ref.name, pluginDir, {
           token,
           secrets
@@ -9028,7 +10133,7 @@ Try:
   if (force && !dryRun) {
     const entry = marketplace.manifest.plugins.find((p) => p.name === ref.name);
     if (entry && hasUrlSource(entry)) {
-      await rm11(pluginCacheDir(ref.marketplace, ref.name), {
+      await rm12(pluginCacheDir(ref.marketplace, ref.name), {
         recursive: true,
         force: true
       });
@@ -9037,6 +10142,9 @@ Try:
   const resolveFn = input.resolvePluginFn ?? resolvePlugin;
   let plugin;
   try {
+    output.dim(
+      `  Reading local plugin package: ${ref.name}@${ref.marketplace}`
+    );
     plugin = await resolveFn(ref, marketplace, { dryRun });
   } catch (err) {
     if (err instanceof PluginNotFoundInMarketplaceError && marketplace.source.kind === "rush") {
@@ -9111,6 +10219,12 @@ Try:
         claudeMarketplaceSource: claudeMarketplaceSourceFrom(
           opts.marketplace
         )
+      } : {},
+      ...target === "claude-3p" ? {
+        claude3pMarketplaceSource: claude3pMarketplaceSourceFrom(
+          opts.marketplace
+        ),
+        ...input.claude3pAccount !== void 0 ? { claude3pAccount: input.claude3pAccount } : {}
       } : {}
     }));
     const installer = factory(t, {
@@ -9160,9 +10274,9 @@ Try:
     try {
       const [{ syncCodexMarketplaceMirror: syncCodexMarketplaceMirror2 }, { pickContentLoader: pickContentLoader2 }] = await Promise.all([
         import("./mirror-SQ6GNVP5.js"),
-        import("./_codex-content-loader-EXSX7ZGI.js")
+        import("./_codex-content-loader-WAPA56U3.js")
       ]);
-      await syncCodexMarketplaceMirror2(input.home ?? homedir17(), marketplace, {
+      await syncCodexMarketplaceMirror2(input.home ?? homedir18(), marketplace, {
         contentLoader: pickContentLoader2(marketplace)
       });
     } catch (err) {
@@ -9208,7 +10322,7 @@ function formatRegistryError(err) {
 }
 function registerInstallCommand(group, _root) {
   group.command("install").description(
-    "Install a plugin to one or more IDEs (Claude Code, Codex, Cursor)"
+    "Install a plugin to one or more IDEs (Claude Code, Codex, Cursor, Claude-3p)"
   ).argument("<ref>", "plugin reference: <name> or <name>@<marketplace>").option(
     "--target <list>",
     `comma-separated targets (default: ${[...DEFAULT_TARGETS2].join(",")})`
@@ -9322,6 +10436,8 @@ function targetDisplayName(t) {
       return "Codex";
     case "cursor":
       return "Cursor";
+    case "claude-3p":
+      return "Claude-3p";
     default: {
       const _exhaustive = t;
       void _exhaustive;
@@ -9337,6 +10453,8 @@ function nextStepFor(t) {
       return "fully quit Codex (Cmd+Q on macOS) and reopen \u2014 Codex does not hot-reload config.toml; just opening a new chat is not enough";
     case "cursor":
       return "restart Cursor";
+    case "claude-3p":
+      return "start a new Claude-3p conversation; if the plugin is still missing, fully quit Claude-3p (Cmd+Q on macOS) and reopen";
     default:
       return "restart the IDE";
   }
@@ -9344,11 +10462,14 @@ function nextStepFor(t) {
 
 // src/commands/plugin/list.ts
 async function runList2(input = {}) {
-  const targets = parseTargets2(input.targetRaw);
   const cache = input.cache ?? new MarketplaceCache(input.home !== void 0 ? { home: input.home } : {});
   const registry = input.registry ?? await RushRegistryStore.load(
     input.home !== void 0 ? { home: input.home } : {}
   );
+  const targets = parseTargets2(
+    input.targetRaw,
+    maintenanceTargetsFromRegistry(registry)
+  );
   if (input.available) {
     return runAvailable(cache, registry, targets);
   }
@@ -9495,16 +10616,15 @@ function statusIcon2(status) {
 
 // src/commands/plugin/uninstall.ts
 async function runUninstall(input) {
-  const targets = parseTargets2(input.targetRaw);
   const targetExplicit = input.targetExplicit ?? input.targetRaw !== void 0;
   const dryRun = input.dryRun === true;
+  const registry = input.registry ?? await RushRegistryStore.load(
+    input.home !== void 0 ? { home: input.home } : {}
+  );
   const cache = input.cache ?? new MarketplaceCache(input.home !== void 0 ? { home: input.home } : {});
   const ref = await parsePluginRef(input.ref, cache).catch(async (err) => {
     if (err instanceof RushError && err.code === "PLUGIN_NOT_FOUND") {
-      const reg = input.registry ?? await RushRegistryStore.load(
-        input.home !== void 0 ? { home: input.home } : {}
-      );
-      const all = reg.list();
+      const all = registry.list();
       const matches = all.filter(([r]) => r.name === input.ref.trim());
       if (matches.length === 1) {
         const only = matches[0];
@@ -9522,13 +10642,20 @@ async function runUninstall(input) {
     }
     throw err;
   });
+  const targets = parseTargets2(
+    input.targetRaw,
+    maintenanceTargetsForRef(registry, ref)
+  );
+  const claude3pAccount = claude3pAccountFromRegistryEntry(registry.get(ref));
   const results = [];
   for (const t of targets) {
     const factory = input.installerFactory ?? ((target, opts) => defaultInstallerFactory(target, {
-      ...opts.home !== void 0 ? { home: opts.home } : {}
+      ...opts.home !== void 0 ? { home: opts.home } : {},
+      ...target === "claude-3p" && claude3pAccount !== void 0 ? { claude3pAccount } : {}
     }));
     const installer = factory(t, {
-      ...input.home !== void 0 ? { home: input.home } : {}
+      ...input.home !== void 0 ? { home: input.home } : {},
+      ...t === "claude-3p" && claude3pAccount !== void 0 ? { claude3pAccount } : {}
     });
     try {
       const result = await installer.uninstall(ref, { dryRun });
@@ -9557,11 +10684,8 @@ async function runUninstall(input) {
   let registryError;
   if (!dryRun) {
     try {
-      const store = input.registry ?? await RushRegistryStore.load(
-        input.home !== void 0 ? { home: input.home } : {}
-      );
       const successTargets = results.filter((r) => r.status === "ok").map((r) => r.target);
-      await applyUninstallToRegistry(store, ref, successTargets);
+      await applyUninstallToRegistry(registry, ref, successTargets);
     } catch (err) {
       registryError = formatRegistryError2(err);
     }
@@ -9646,6 +10770,16 @@ function printUninstallSummary(result) {
       }
     }
   }
+  const claude3pOk = results.some(
+    (r) => r.target === "claude-3p" && r.status === "ok"
+  );
+  if (claude3pOk && !dryRun) {
+    output.newline();
+    output.dim("Next steps:");
+    output.dim(
+      "  - Claude-3p: start a new Claude-3p conversation; if the plugin is still visible, fully quit Claude-3p (Cmd+Q on macOS) and reopen"
+    );
+  }
   if (result.registryError) {
     output.newline();
     output.warn(result.registryError);
@@ -9676,6 +10810,8 @@ function targetDisplayName2(t) {
       return "Codex";
     case "cursor":
       return "Cursor";
+    case "claude-3p":
+      return "Claude-3p";
     default: {
       const _exhaustive = t;
       void _exhaustive;
@@ -9686,13 +10822,16 @@ function targetDisplayName2(t) {
 
 // src/commands/plugin/update.ts
 async function runUpdate3(input = {}) {
-  const targets = parseTargets2(input.targetRaw);
   const targetExplicit = input.targetExplicit ?? input.targetRaw !== void 0;
   const dryRun = input.dryRun === true;
   const cache = input.cache ?? new MarketplaceCache(input.home !== void 0 ? { home: input.home } : {});
   const registry = input.registry ?? await RushRegistryStore.load(
     input.home !== void 0 ? { home: input.home } : {}
   );
+  const targets = parseTargets2(
+    input.targetRaw,
+    maintenanceTargetsFromRegistry(registry)
+  );
   const refs = await collectRefs(input, cache, registry);
   if (refs.length === 0) {
     return {
@@ -9758,14 +10897,16 @@ async function runUpdate3(input = {}) {
       plugins.push({ ref, fromVersion, toVersion, upToDate: false });
       continue;
     }
+    const claude3pAccount = input.targetRaw === void 0 ? claude3pAccountFromRegistryEntry(registry.get(ref)) : void 0;
     const installInput = {
       ref: `${ref.name}@${ref.marketplace}`,
-      ...input.targetRaw !== void 0 ? { targetRaw: input.targetRaw } : {},
+      ...input.targetRaw !== void 0 ? { targetRaw: input.targetRaw } : { targetRaw: maintenanceTargetsForRef(registry, ref).join(",") },
       targetExplicit,
       force: true,
       ...input.home !== void 0 ? { home: input.home } : {},
       cache,
-      registry
+      registry,
+      ...claude3pAccount !== void 0 ? { claude3pAccount } : {}
     };
     const result = await installRunner(installInput);
     plugins.push({
@@ -9973,7 +11114,7 @@ function getReskillInvocation() {
   };
 }
 function runReskill(args) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve25, reject) => {
     const reskill = getReskillInvocation();
     const child = spawn2(reskill.command, [...reskill.args, ...args], {
       env: createReskillEnv(),
@@ -9983,10 +11124,10 @@ function runReskill(args) {
     child.on("close", (code, signal) => {
       if (signal) {
         output.error(`reskill exited from signal ${signal}`);
-        resolve23(1);
+        resolve25(1);
         return;
       }
-      resolve23(code ?? 1);
+      resolve25(code ?? 1);
     });
   });
 }
@@ -10060,7 +11201,7 @@ function registerSkillCommand(program) {
 
 // src/commands/task/index.ts
 import { createWriteStream } from "fs";
-import { mkdir as mkdir10, readFile as readFile13, stat as stat8 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile14, stat as stat9 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
@@ -10086,13 +11227,13 @@ async function readStdinIfPiped() {
   if (process.stdin.isTTY) {
     return null;
   }
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve25, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
       chunks.push(chunk);
     });
     process.stdin.on("end", () => {
-      resolve23(Buffer.concat(chunks).toString("utf-8").trim());
+      resolve25(Buffer.concat(chunks).toString("utf-8").trim());
     });
     process.stdin.on("error", reject);
   });
@@ -10293,7 +11434,7 @@ function buildDeployUrl(prefix, env, apiBaseUrl) {
 }
 
 // src/commands/task/push.ts
-import { resolve as resolve21 } from "path";
+import { resolve as resolve23 } from "path";
 import chalk5 from "chalk";
 
 // src/util/env-file.ts
@@ -10437,7 +11578,7 @@ function registerPushSubcommand(task, program) {
     requireAuth();
     const format = resolveFormat(program.opts());
     const client = createClient();
-    const projectPath = resolve21(opts.path);
+    const projectPath = resolve23(opts.path);
     if (format !== "json") {
       output.info("Checking project readiness...");
     }
@@ -10868,7 +12009,7 @@ async function confirmPublish(args) {
   return answer.trim().toLowerCase().startsWith("y");
 }
 function readOneLine() {
-  return new Promise((resolve23) => {
+  return new Promise((resolve25) => {
     let acc = "";
     const onData = (chunk) => {
       acc += chunk.toString("utf-8");
@@ -10876,7 +12017,7 @@ function readOneLine() {
       if (nlIdx !== -1) {
         process.stdin.removeListener("data", onData);
         process.stdin.pause();
-        resolve23(acc.slice(0, nlIdx));
+        resolve25(acc.slice(0, nlIdx));
       }
     };
     process.stdin.resume();
@@ -11062,12 +12203,12 @@ function registerDomainSubcommand(task, program) {
 }
 
 // src/commands/task/env.ts
-import { resolve as resolve22 } from "path";
+import { resolve as resolve24 } from "path";
 
 // src/util/prompt.ts
 import { createInterface } from "readline";
 function promptSecret(message) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve25, reject) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -11080,7 +12221,7 @@ function promptSecret(message) {
     rl.question("", (answer) => {
       rl.close();
       process.stdout.write("\n");
-      resolve23(answer);
+      resolve25(answer);
     });
     rl.on("SIGINT", () => {
       rl.close();
@@ -11103,7 +12244,7 @@ var NO_PROJECT_HINT2 = [
 ].join("\n");
 function resolveProjectId(opts) {
   if (opts.project) return Promise.resolve(opts.project);
-  const projectPath = resolve22(opts.path ?? ".");
+  const projectPath = resolve24(opts.path ?? ".");
   const remoteUrl = isGitRepo(projectPath) ? getRemoteUrl(projectPath) : null;
   const idFromRemote = remoteUrl ? extractRushProjectId(remoteUrl) : null;
   if (idFromRemote) return Promise.resolve(idFromRemote);
@@ -11831,7 +12972,7 @@ async function downloadFile(file2, destPath, client) {
   if (!response.body) {
     throw new Error("No response body");
   }
-  await mkdir10(path3.dirname(destPath), { recursive: true });
+  await mkdir11(path3.dirname(destPath), { recursive: true });
   const nodeStream = Readable.fromWeb(
     response.body
   );
@@ -12372,7 +13513,7 @@ async function uploadFileForTask(client, localPath) {
   const resolved = path3.resolve(localPath);
   let fileStat;
   try {
-    fileStat = await stat8(resolved);
+    fileStat = await stat9(resolved);
   } catch {
     throw new RushError(`File not found: ${localPath}`);
   }
@@ -12386,7 +13527,7 @@ async function uploadFileForTask(client, localPath) {
   }
   const filename = path3.basename(resolved);
   const mediaType = guessMediaType(resolved);
-  const buf = await readFile13(resolved);
+  const buf = await readFile14(resolved);
   const blob = new File([buf], filename, { type: mediaType });
   const formData = new FormData();
   formData.append("file", blob);
@@ -12439,9 +13580,9 @@ function registerCommands(program) {
 }
 
 // src/util/update-check.ts
-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";
+import { mkdir as mkdir12, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
+import { homedir as homedir19 } from "os";
+import { dirname as dirname10, join as join11 } 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";
@@ -12464,19 +13605,19 @@ function isNewerVersion(current, latest) {
 }
 async function writeLastCheck(checkFile) {
   try {
-    await mkdir11(dirname9(checkFile), { recursive: true });
-    await writeFile7(checkFile, JSON.stringify({ lastCheck: Date.now() }));
+    await mkdir12(dirname10(checkFile), { recursive: true });
+    await writeFile8(checkFile, JSON.stringify({ lastCheck: Date.now() }));
   } catch {
   }
 }
 async function checkForUpdate(currentVersion) {
-  const rushDir = join10(homedir18(), ".rush");
-  const checkFile = join10(rushDir, "update-check.json");
+  const rushDir = join11(homedir19(), ".rush");
+  const checkFile = join11(rushDir, "update-check.json");
   try {
     if (process.env.CI) return;
     let lastCheck = 0;
     try {
-      const data = JSON.parse(await readFile14(checkFile, "utf-8"));
+      const data = JSON.parse(await readFile15(checkFile, "utf-8"));
       lastCheck = data.lastCheck ?? 0;
     } catch {
     }