allagents 0.17.2 → 0.20.0

package/dist/index.js

@@ -11382,7 +11382,7 @@ var init_zod = __esm(() => {
 });
 
 // src/models/workspace-config.ts
-var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, VscodeConfigSchema, WorkspaceConfigSchema;
+var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, VscodeConfigSchema, SyncModeSchema, WorkspaceConfigSchema;
 var init_workspace_config = __esm(() => {
   init_zod();
   RepositorySchema = exports_external.object({
@@ -11417,12 +11417,15 @@ var init_workspace_config = __esm(() => {
   VscodeConfigSchema = exports_external.object({
     output: exports_external.string().optional()
   });
+  SyncModeSchema = exports_external.enum(["symlink", "copy"]);
   WorkspaceConfigSchema = exports_external.object({
     workspace: WorkspaceSchema.optional(),
     repositories: exports_external.array(RepositorySchema),
     plugins: exports_external.array(PluginSourceSchema),
     clients: exports_external.array(ClientTypeSchema),
-    vscode: VscodeConfigSchema.optional()
+    vscode: VscodeConfigSchema.optional(),
+    syncMode: SyncModeSchema.optional(),
+    disabledSkills: exports_external.array(exports_external.string()).optional()
   });
 });
 
@@ -21223,7 +21226,10 @@ var init_glob_patterns = __esm(() => {
 });
 
 // src/models/client-mapping.ts
-var CLIENT_MAPPINGS, USER_CLIENT_MAPPINGS;
+function isUniversalClient(client) {
+  return CLIENT_MAPPINGS[client].skillsPath === CANONICAL_SKILLS_PATH;
+}
+var CLIENT_MAPPINGS, CANONICAL_SKILLS_PATH = ".agents/skills/", USER_CLIENT_MAPPINGS;
 var init_client_mapping = __esm(() => {
   CLIENT_MAPPINGS = {
     claude: {
@@ -24858,10 +24864,72 @@ var init_skill = __esm(() => {
   import_gray_matter = __toESM(require_gray_matter(), 1);
 });
 
+// src/utils/symlink.ts
+import { symlink, lstat, readlink, rm as rm2, mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2, relative, resolve as resolve4 } from "node:path";
+import { platform } from "node:os";
+import { realpath } from "node:fs/promises";
+async function resolveParentSymlinks(path) {
+  const resolved = resolve4(path);
+  const dir = dirname2(resolved);
+  const base = resolved.substring(dir.length + 1);
+  try {
+    const realDir = await realpath(dir);
+    return `${realDir}/${base}`;
+  } catch {
+    return resolved;
+  }
+}
+function resolveSymlinkTarget(linkPath, linkTarget) {
+  return resolve4(dirname2(linkPath), linkTarget);
+}
+async function createSymlink(target, linkPath) {
+  try {
+    const resolvedTarget = resolve4(target);
+    const resolvedLinkPath = resolve4(linkPath);
+    if (resolvedTarget === resolvedLinkPath) {
+      return true;
+    }
+    const realTarget = await resolveParentSymlinks(target);
+    const realLinkPath = await resolveParentSymlinks(linkPath);
+    if (realTarget === realLinkPath) {
+      return true;
+    }
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = await readlink(linkPath);
+        if (resolveSymlinkTarget(linkPath, existingTarget) === resolvedTarget) {
+          return true;
+        }
+        await rm2(linkPath);
+      } else {
+        await rm2(linkPath, { recursive: true });
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") {
+        try {
+          await rm2(linkPath, { force: true });
+        } catch {}
+      }
+    }
+    const linkDir = dirname2(linkPath);
+    await mkdir2(linkDir, { recursive: true });
+    const realLinkDir = await resolveParentSymlinks(linkDir);
+    const relativePath = relative(realLinkDir, target);
+    const symlinkType = platform() === "win32" ? "junction" : undefined;
+    await symlink(relativePath, linkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_symlink = () => {};
+
 // src/core/transform.ts
-import { readFile as readFile4, writeFile, mkdir as mkdir2, cp, readdir as readdir2 } from "node:fs/promises";
+import { readFile as readFile4, writeFile, mkdir as mkdir3, cp, readdir as readdir2 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join6, dirname as dirname2 } from "node:path";
+import { join as join6, dirname as dirname3 } from "node:path";
 async function ensureWorkspaceRules(filePath, rules) {
   const rulesContent = rules ?? WORKSPACE_RULES;
   const startMarker = "<!-- WORKSPACE-RULES:START -->";
@@ -24898,7 +24966,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   }
   const destDir = join6(workspacePath, mapping.commandsPath);
   if (!dryRun) {
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
   }
   const files = await readdir2(sourceDir);
   const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -24924,7 +24992,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   return Promise.all(copyPromises);
 }
 async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false, skillNameMap } = options2;
+  const { dryRun = false, skillNameMap, syncMode = "copy", canonicalSkillsPath } = options2;
   const mapping = getMapping(client, options2);
   const results = [];
   if (!mapping.skillsPath) {
@@ -24936,10 +25004,14 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
   }
   const destDir = join6(workspacePath, mapping.skillsPath);
   if (!dryRun) {
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
   }
   const entries = await readdir2(sourceDir, { withFileTypes: true });
-  const skillDirs = entries.filter((e) => e.isDirectory());
+  let skillDirs = entries.filter((e) => e.isDirectory());
+  if (skillNameMap) {
+    skillDirs = skillDirs.filter((e) => skillNameMap.has(e.name));
+  }
+  const useSymlinks = syncMode === "symlink" && !isUniversalClient(client) && canonicalSkillsPath;
   const copyPromises = skillDirs.map(async (entry) => {
     const skillSourcePath = join6(sourceDir, entry.name);
     const resolvedName = skillNameMap?.get(entry.name) ?? entry.name;
@@ -24960,6 +25032,17 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
         action: "copied"
       };
     }
+    if (useSymlinks) {
+      const canonicalSkillPath = join6(workspacePath, canonicalSkillsPath, resolvedName);
+      const symlinkCreated = await createSymlink(canonicalSkillPath, skillDestPath);
+      if (symlinkCreated) {
+        return {
+          source: canonicalSkillPath,
+          destination: skillDestPath,
+          action: "copied"
+        };
+      }
+    }
     try {
       await cp(skillSourcePath, skillDestPath, { recursive: true });
       return {
@@ -24978,14 +25061,15 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
   });
   return Promise.all(copyPromises);
 }
-async function collectPluginSkills(pluginPath, pluginSource) {
+async function collectPluginSkills(pluginPath, pluginSource, disabledSkills, pluginName) {
   const skillsDir = join6(pluginPath, "skills");
   if (!existsSync4(skillsDir)) {
     return [];
   }
   const entries = await readdir2(skillsDir, { withFileTypes: true });
   const skillDirs = entries.filter((e) => e.isDirectory());
-  return skillDirs.map((entry) => ({
+  const filteredDirs = disabledSkills && pluginName ? skillDirs.filter((e) => !disabledSkills.has(`${pluginName}:${e.name}`)) : skillDirs;
+  return filteredDirs.map((entry) => ({
     folderName: entry.name,
     skillPath: join6(skillsDir, entry.name),
     pluginPath,
@@ -25008,7 +25092,7 @@ async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
     results.push({ source: sourceDir, destination: destDir, action: "copied" });
     return results;
   }
-  await mkdir2(destDir, { recursive: true });
+  await mkdir3(destDir, { recursive: true });
   try {
     await cp(sourceDir, destDir, { recursive: true });
     results.push({ source: sourceDir, destination: destDir, action: "copied" });
@@ -25035,7 +25119,7 @@ async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
   }
   const destDir = join6(workspacePath, mapping.agentsPath);
   if (!dryRun) {
-    await mkdir2(destDir, { recursive: true });
+    await mkdir3(destDir, { recursive: true });
   }
   const files = await readdir2(sourceDir);
   const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -25061,10 +25145,15 @@ async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
   return Promise.all(copyPromises);
 }
 async function copyPluginToWorkspace(pluginPath, workspacePath, client, options2 = {}) {
-  const { skillNameMap, ...baseOptions } = options2;
+  const { skillNameMap, syncMode, canonicalSkillsPath, ...baseOptions } = options2;
   const [commandResults, skillResults, hookResults, agentResults] = await Promise.all([
     copyCommands(pluginPath, workspacePath, client, baseOptions),
-    copySkills(pluginPath, workspacePath, client, { ...baseOptions, ...skillNameMap && { skillNameMap } }),
+    copySkills(pluginPath, workspacePath, client, {
+      ...baseOptions,
+      ...skillNameMap && { skillNameMap },
+      ...syncMode && { syncMode },
+      ...canonicalSkillsPath && { canonicalSkillsPath }
+    }),
     copyHooks(pluginPath, workspacePath, client, baseOptions),
     copyAgents(pluginPath, workspacePath, client, baseOptions)
   ]);
@@ -25181,7 +25270,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
           continue;
         }
         try {
-          await mkdir2(dirname2(destPath), { recursive: true });
+          await mkdir3(dirname3(destPath), { recursive: true });
           const content = await readFile4(resolved.sourcePath, "utf-8");
           await writeFile(destPath, content, "utf-8");
           results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
@@ -25252,7 +25341,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
       continue;
     }
     try {
-      await mkdir2(dirname2(destPath), { recursive: true });
+      await mkdir3(dirname3(destPath), { recursive: true });
       const content = await readFile4(srcPath, "utf-8");
       await writeFile(destPath, content, "utf-8");
       results.push({ source: srcPath, destination: destPath, action: "copied" });
@@ -25292,6 +25381,7 @@ var init_transform = __esm(() => {
   init_skill();
   init_constants();
   init_plugin_path();
+  init_symlink();
   AGENT_FILES2 = ["AGENTS.md", "CLAUDE.md"];
   injectWorkspaceRules = ensureWorkspaceRules;
 });
@@ -25351,7 +25441,7 @@ var init_marketplace_manifest = __esm(() => {
 // src/utils/marketplace-manifest-parser.ts
 import { readFile as readFile5 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join7, resolve as resolve4 } from "node:path";
+import { join as join7, resolve as resolve5 } from "node:path";
 async function parseMarketplaceManifest(marketplacePath) {
   const manifestPath = join7(marketplacePath, MANIFEST_PATH);
   if (!existsSync5(manifestPath)) {
@@ -25455,7 +25545,7 @@ function resolvePluginSourcePath(source, marketplacePath) {
   if (typeof source === "object") {
     return source.url;
   }
-  return resolve4(marketplacePath, source);
+  return resolve5(marketplacePath, source);
 }
 var MANIFEST_PATH = ".claude-plugin/marketplace.json";
 var init_marketplace_manifest_parser = __esm(() => {
@@ -25468,24 +25558,29 @@ __export(exports_user_workspace, {
   resolveGitHubIdentity: () => resolveGitHubIdentity,
   removeUserPluginsForMarketplace: () => removeUserPluginsForMarketplace,
   removeUserPlugin: () => removeUserPlugin,
+  removeUserDisabledSkill: () => removeUserDisabledSkill,
   isUserConfigPath: () => isUserConfigPath,
   hasUserPlugin: () => hasUserPlugin,
   getUserWorkspaceConfigPath: () => getUserWorkspaceConfigPath,
   getUserWorkspaceConfig: () => getUserWorkspaceConfig,
   getUserPluginsForMarketplace: () => getUserPluginsForMarketplace,
+  getUserDisabledSkills: () => getUserDisabledSkills,
+  getInstalledUserPlugins: () => getInstalledUserPlugins,
+  getInstalledProjectPlugins: () => getInstalledProjectPlugins,
   ensureUserWorkspace: () => ensureUserWorkspace,
-  addUserPlugin: () => addUserPlugin
+  addUserPlugin: () => addUserPlugin,
+  addUserDisabledSkill: () => addUserDisabledSkill
 });
-import { readFile as readFile6, writeFile as writeFile2, mkdir as mkdir3 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile2, mkdir as mkdir4 } from "node:fs/promises";
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join8, resolve as resolve5 } from "node:path";
+import { join as join8, resolve as resolve6 } from "node:path";
 function getUserWorkspaceConfigPath() {
   return join8(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
 }
 function isUserConfigPath(workspacePath) {
   const projectConfigPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
   const userConfigPath = getUserWorkspaceConfigPath();
-  return resolve5(projectConfigPath) === resolve5(userConfigPath);
+  return resolve6(projectConfigPath) === resolve6(userConfigPath);
 }
 async function ensureUserWorkspace() {
   const configPath = getUserWorkspaceConfigPath();
@@ -25494,9 +25589,9 @@ async function ensureUserWorkspace() {
   const defaultConfig = {
     repositories: [],
     plugins: [],
-    clients: [...ALL_CLIENTS]
+    clients: [...DEFAULT_USER_CLIENTS]
   };
-  await mkdir3(getAllagentsDir(), { recursive: true });
+  await mkdir4(getAllagentsDir(), { recursive: true });
   await writeFile2(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
 }
 async function getUserWorkspaceConfig() {
@@ -25662,7 +25757,98 @@ async function addPluginToUserConfig(plugin, configPath, autoRegistered) {
     };
   }
 }
-var ALL_CLIENTS;
+async function getUserDisabledSkills() {
+  const config = await getUserWorkspaceConfig();
+  return config?.disabledSkills ?? [];
+}
+async function addUserDisabledSkill(skillKey) {
+  await ensureUserWorkspace();
+  const configPath = getUserWorkspaceConfigPath();
+  try {
+    const content = await readFile6(configPath, "utf-8");
+    const config = load(content);
+    const disabledSkills = config.disabledSkills ?? [];
+    if (disabledSkills.includes(skillKey)) {
+      return { success: false, error: `Skill '${skillKey}' is already disabled` };
+    }
+    config.disabledSkills = [...disabledSkills, skillKey];
+    await writeFile2(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function removeUserDisabledSkill(skillKey) {
+  await ensureUserWorkspace();
+  const configPath = getUserWorkspaceConfigPath();
+  try {
+    const content = await readFile6(configPath, "utf-8");
+    const config = load(content);
+    const disabledSkills = config.disabledSkills ?? [];
+    if (!disabledSkills.includes(skillKey)) {
+      return { success: false, error: `Skill '${skillKey}' is already enabled` };
+    }
+    config.disabledSkills = disabledSkills.filter((s) => s !== skillKey);
+    if (config.disabledSkills.length === 0) {
+      config.disabledSkills = undefined;
+    }
+    await writeFile2(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function getInstalledUserPlugins() {
+  const config = await getUserWorkspaceConfig();
+  if (!config)
+    return [];
+  const result = [];
+  for (const plugin of config.plugins) {
+    const parsed = parsePluginSpec(plugin);
+    if (parsed) {
+      result.push({
+        spec: plugin,
+        name: parsed.plugin,
+        marketplace: parsed.marketplaceName,
+        scope: "user"
+      });
+    }
+  }
+  return result;
+}
+async function getInstalledProjectPlugins(workspacePath) {
+  const configPath = join8(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync6(configPath))
+    return [];
+  try {
+    const content = await readFile6(configPath, "utf-8");
+    const config = load(content);
+    if (!config?.plugins)
+      return [];
+    const result = [];
+    for (const plugin of config.plugins) {
+      const parsed = parsePluginSpec(plugin);
+      if (parsed) {
+        result.push({
+          spec: plugin,
+          name: parsed.plugin,
+          marketplace: parsed.marketplaceName,
+          scope: "project"
+        });
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+var DEFAULT_USER_CLIENTS;
 var init_user_workspace = __esm(() => {
   init_js_yaml();
   init_constants();
@@ -25670,8 +25856,7 @@ var init_user_workspace = __esm(() => {
   init_marketplace();
   init_plugin_path();
   init_marketplace_manifest_parser();
-  ALL_CLIENTS = [
-    "claude",
+  DEFAULT_USER_CLIENTS = [
     "copilot",
     "codex",
     "cursor",
@@ -25683,16 +25868,16 @@ var init_user_workspace = __esm(() => {
 });
 
 // src/core/marketplace.ts
-import { mkdir as mkdir4, readFile as readFile7, readdir as readdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, readdir as readdir3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
-import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
+import { basename as basename2, join as join9, resolve as resolve7 } from "node:path";
 function parseLocation(location) {
   const [owner = "", repo = "", ...rest] = location.split("/");
   const branch = rest.length > 0 ? rest.join("/") : undefined;
   return { owner, repo, ...branch !== undefined && { branch } };
 }
 function getAllagentsDir() {
-  return resolve6(getHomeDir(), ".allagents");
+  return resolve7(getHomeDir(), ".allagents");
 }
 function getMarketplacesDir() {
   return join9(getAllagentsDir(), "plugins", "marketplaces");
@@ -25716,19 +25901,27 @@ async function saveRegistry(registry) {
   const registryPath = getRegistryPath();
   const dir = getAllagentsDir();
   if (!existsSync7(dir)) {
-    await mkdir4(dir, { recursive: true });
+    await mkdir5(dir, { recursive: true });
   }
   await writeFile3(registryPath, `${JSON.stringify(registry, null, 2)}
 `);
 }
-function parseMarketplaceSource(source) {
-  if (WELL_KNOWN_MARKETPLACES[source]) {
-    return {
-      type: "github",
-      location: WELL_KNOWN_MARKETPLACES[source],
-      name: source
-    };
+function getSourceLocationKey(source) {
+  if (source.type === "github") {
+    const { owner, repo } = parseLocation(source.location);
+    return `${owner}/${repo}`;
+  }
+  return source.location;
+}
+function findBySourceLocation(registry, sourceLocation) {
+  for (const entry of Object.values(registry.marketplaces)) {
+    if (getSourceLocationKey(entry.source) === sourceLocation) {
+      return entry;
+    }
   }
+  return null;
+}
+function parseMarketplaceSource(source) {
   if (source.startsWith("https://github.com/")) {
     const match = source.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/(.+))?$/);
     if (match) {
@@ -25746,7 +25939,7 @@ function parseMarketplaceSource(source) {
     return null;
   }
   if (source.startsWith("/") || source.startsWith(".")) {
-    const absPath = resolve6(source);
+    const absPath = resolve7(source);
     const name = basename2(absPath) || "local";
     return {
       type: "local",
@@ -25772,7 +25965,7 @@ async function addMarketplace(source, customName, branch) {
     return {
       success: false,
       error: `Invalid marketplace source: ${source}
-  Use: GitHub URL, owner/repo, local path, or well-known name`
+  Use: GitHub URL, owner/repo, or local path`
     };
   }
   const effectiveBranch = branch || parsed.branch;
@@ -25800,13 +25993,18 @@ async function addMarketplace(source, customName, branch) {
       error: `Marketplace '${name}' already exists. Use 'update' to refresh it.`
     };
   }
+  const sourceLocation = parsed.type === "github" ? `${parseLocation(parsed.location).owner}/${parseLocation(parsed.location).repo}` : parsed.location;
+  const existingBySource = findBySourceLocation(registry, sourceLocation);
+  if (existingBySource) {
+    return { success: true, marketplace: existingBySource };
+  }
   let marketplacePath;
   if (parsed.type === "github") {
     marketplacePath = join9(getMarketplacesDir(), name);
     if (existsSync7(marketplacePath)) {} else {
       const parentDir = getMarketplacesDir();
       if (!existsSync7(parentDir)) {
-        await mkdir4(parentDir, { recursive: true });
+        await mkdir5(parentDir, { recursive: true });
       }
       const { owner, repo } = parseLocation(parsed.location);
       const repoUrl = gitHubUrl(owner, repo);
@@ -25894,6 +26092,9 @@ async function removeMarketplace(name) {
   const entry = registry.marketplaces[name];
   delete registry.marketplaces[name];
   await saveRegistry(registry);
+  if (existsSync7(entry.path)) {
+    await rm3(entry.path, { recursive: true, force: true });
+  }
   const { removeUserPluginsForMarketplace: removeUserPluginsForMarketplace2 } = await Promise.resolve().then(() => (init_user_workspace(), exports_user_workspace));
   const removedUserPlugins = await removeUserPluginsForMarketplace2(name);
   return {
@@ -25916,11 +26117,7 @@ async function findMarketplace(name, sourceLocation) {
     return registry.marketplaces[name];
   }
   if (sourceLocation) {
-    for (const entry of Object.values(registry.marketplaces)) {
-      if (entry.source.location === sourceLocation) {
-        return entry;
-      }
-    }
+    return findBySourceLocation(registry, sourceLocation);
   }
   return null;
 }
@@ -25997,7 +26194,7 @@ async function getMarketplacePluginsFromManifest(marketplacePath) {
     const resolvedSource = resolvePluginSourcePath(plugin.source, marketplacePath);
     const info = {
       name: plugin.name,
-      path: typeof plugin.source === "string" ? resolve6(marketplacePath, plugin.source) : resolvedSource,
+      path: typeof plugin.source === "string" ? resolve7(marketplacePath, plugin.source) : resolvedSource,
       description: plugin.description,
       source: resolvedSource
     };
@@ -26082,7 +26279,7 @@ async function resolvePluginSpec(spec, options2 = {}) {
     const pluginEntry = manifestResult.data.plugins.find((p) => p.name === parsed.plugin);
     if (pluginEntry) {
       if (typeof pluginEntry.source === "string") {
-        const resolvedPath = resolve6(marketplacePath, pluginEntry.source);
+        const resolvedPath = resolve7(marketplacePath, pluginEntry.source);
         if (existsSync7(resolvedPath)) {
           return {
             path: resolvedPath,
@@ -26137,7 +26334,7 @@ async function refreshMarketplace(marketplace) {
   delete registry.marketplaces[marketplace.name];
   await saveRegistry(registry);
   if (existsSync7(marketplace.path)) {
-    await rm2(marketplace.path, { recursive: true, force: true });
+    await rm3(marketplace.path, { recursive: true, force: true });
   }
   return addMarketplace(`${owner}/${repo}`, marketplace.name, branch);
 }
@@ -26202,35 +26399,22 @@ async function resolvePluginSpecWithAutoRegister(spec, options2 = {}) {
     ...marketplace.name !== marketplaceName && { registeredAs: marketplace.name }
   };
 }
-async function autoRegisterMarketplace(name) {
-  const wellKnown = getWellKnownMarketplaces();
-  if (wellKnown[name]) {
-    console.log(`Auto-registering well-known marketplace: ${name}`);
-    const result = await addMarketplace(name);
-    if (!result.success) {
-      return { success: false, error: result.error || "Unknown error" };
-    }
-    return { success: true, name };
-  }
-  if (name.includes("/") && !name.includes("://")) {
-    const parts = name.split("/");
+async function autoRegisterMarketplace(source) {
+  if (source.includes("/") && !source.includes("://")) {
+    const parts = source.split("/");
     if (parts.length === 2 && parts[0] && parts[1]) {
-      console.log(`Auto-registering GitHub marketplace: ${name}`);
-      const result = await addMarketplace(name);
+      console.log(`Auto-registering GitHub marketplace: ${source}`);
+      const result = await addMarketplace(source);
       if (!result.success) {
         return { success: false, error: result.error || "Unknown error" };
       }
-      const registeredName = result.marketplace?.name ?? parts[1];
-      return { success: true, name: registeredName };
+      return { success: true, name: result.marketplace?.name ?? parts[1] };
     }
   }
   return {
     success: false,
-    error: `Marketplace '${name}' not found.
-  Options:
-  1. Use fully qualified name: plugin@owner/repo
-  2. Register first: allagents plugin marketplace add <source>
-  3. Well-known marketplaces: ${Object.keys(wellKnown).join(", ")}`
+    error: `Marketplace '${source}' not found.
+  Use fully qualified format: plugin@owner/repo`
   };
 }
 function isPluginSpec(spec) {
@@ -26240,10 +26424,48 @@ function isPluginSpec(spec) {
   }
   return true;
 }
-function getWellKnownMarketplaces() {
-  return { ...WELL_KNOWN_MARKETPLACES };
+function extractUniqueMarketplaceSources(plugins) {
+  const sources = new Set;
+  for (const plugin of plugins) {
+    if (!isPluginSpec(plugin))
+      continue;
+    const parsed = parsePluginSpec(plugin);
+    if (!parsed)
+      continue;
+    if (parsed.owner && parsed.repo) {
+      sources.add(`${parsed.owner}/${parsed.repo}`);
+    }
+  }
+  return Array.from(sources);
+}
+async function ensureMarketplacesRegistered(plugins) {
+  const sources = extractUniqueMarketplaceSources(plugins);
+  const results = [];
+  for (const source of sources) {
+    const parts = source.split("/");
+    const sourceLocation = source;
+    const existing = await findMarketplace(parts[1] ?? "", sourceLocation);
+    if (existing) {
+      results.push({ source, success: true, name: existing.name });
+      continue;
+    }
+    const result = await autoRegisterMarketplace(source);
+    results.push({ source, ...result });
+  }
+  return results;
+}
+async function getMarketplaceVersion(marketplacePath) {
+  if (!existsSync7(marketplacePath)) {
+    return null;
+  }
+  try {
+    const git = esm_default(marketplacePath);
+    const log = await git.log({ maxCount: 1, format: { hash: "%h" } });
+    return log.latest?.hash || null;
+  } catch {
+    return null;
+  }
 }
-var WELL_KNOWN_MARKETPLACES;
 var init_marketplace = __esm(() => {
   init_esm();
   init_git();
@@ -26251,13 +26473,10 @@ var init_marketplace = __esm(() => {
   init_plugin();
   init_plugin_path();
   init_constants();
-  WELL_KNOWN_MARKETPLACES = {
-    "claude-plugins-official": "anthropics/claude-plugins-official"
-  };
 });
 
 // src/core/workspace-modify.ts
-import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir5 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir6 } from "node:fs/promises";
 import { existsSync as existsSync8 } from "node:fs";
 import { join as join10 } from "node:path";
 async function setClients(clients, workspacePath = process.cwd()) {
@@ -26291,7 +26510,7 @@ async function ensureWorkspace(workspacePath) {
     plugins: [],
     clients: [...DEFAULT_PROJECT_CLIENTS]
   };
-  await mkdir5(configDir, { recursive: true });
+  await mkdir6(configDir, { recursive: true });
   await writeFile4(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
 }
 async function addPlugin(plugin, workspacePath = process.cwd()) {
@@ -26407,6 +26626,65 @@ async function removePlugin(plugin, workspacePath = process.cwd()) {
     };
   }
 }
+async function addDisabledSkill(skillKey, workspacePath = process.cwd()) {
+  const configPath = join10(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync8(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
+  }
+  try {
+    const content = await readFile8(configPath, "utf-8");
+    const config = load(content);
+    const disabledSkills = config.disabledSkills ?? [];
+    if (disabledSkills.includes(skillKey)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already disabled`
+      };
+    }
+    config.disabledSkills = [...disabledSkills, skillKey];
+    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function removeDisabledSkill(skillKey, workspacePath = process.cwd()) {
+  const configPath = join10(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync8(configPath)) {
+    return {
+      success: false,
+      error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
+    };
+  }
+  try {
+    const content = await readFile8(configPath, "utf-8");
+    const config = load(content);
+    const disabledSkills = config.disabledSkills ?? [];
+    if (!disabledSkills.includes(skillKey)) {
+      return {
+        success: false,
+        error: `Skill '${skillKey}' is already enabled`
+      };
+    }
+    config.disabledSkills = disabledSkills.filter((s) => s !== skillKey);
+    if (config.disabledSkills.length === 0) {
+      config.disabledSkills = undefined;
+    }
+    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 var DEFAULT_PROJECT_CLIENTS;
 var init_workspace_modify = __esm(() => {
   init_js_yaml();
@@ -26711,9 +26989,9 @@ var init_sync_state = __esm(() => {
 });
 
 // src/core/sync-state.ts
-import { readFile as readFile10, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join12, dirname as dirname3 } from "node:path";
+import { join as join12, dirname as dirname4 } from "node:path";
 function getSyncStatePath(workspacePath) {
   return join12(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
 }
@@ -26741,7 +27019,7 @@ async function saveSyncState(workspacePath, files) {
     lastSync: new Date().toISOString(),
     files
   };
-  await mkdir6(dirname3(statePath), { recursive: true });
+  await mkdir7(dirname4(statePath), { recursive: true });
   await writeFile6(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function getPreviouslySyncedFiles(state, client) {
@@ -26756,11 +27034,11 @@ var init_sync_state2 = __esm(() => {
 });
 
 // src/core/vscode-workspace.ts
-import { resolve as resolve7, basename as basename3, isAbsolute as isAbsolute2 } from "node:path";
+import { resolve as resolve8, basename as basename3, isAbsolute as isAbsolute2 } from "node:path";
 function buildPathPlaceholderMap(repositories, workspacePath) {
   const map2 = new Map;
   for (const repo of repositories) {
-    const absolutePath = resolve7(workspacePath, repo.path);
+    const absolutePath = resolve8(workspacePath, repo.path);
     map2.set(repo.path, absolutePath);
   }
   return map2;
@@ -26795,16 +27073,16 @@ function generateVscodeWorkspace(input) {
   const folders = [];
   const seenPaths = new Set;
   folders.push({ path: "." });
-  seenPaths.add(resolve7(workspacePath, "."));
+  seenPaths.add(resolve8(workspacePath, "."));
   for (const repo of repositories) {
-    const absolutePath = resolve7(workspacePath, repo.path).replace(/\\/g, "/");
+    const absolutePath = resolve8(workspacePath, repo.path).replace(/\\/g, "/");
     folders.push({ path: absolutePath });
     seenPaths.add(absolutePath);
   }
   if (resolvedTemplate && Array.isArray(resolvedTemplate.folders)) {
     for (const folder of resolvedTemplate.folders) {
       const rawPath = folder.path;
-      const normalizedPath = (typeof rawPath === "string" && !isAbsolute2(rawPath) ? resolve7(workspacePath, rawPath) : rawPath).replace(/\\/g, "/");
+      const normalizedPath = (typeof rawPath === "string" && !isAbsolute2(rawPath) ? resolve8(workspacePath, rawPath) : rawPath).replace(/\\/g, "/");
       if (!seenPaths.has(normalizedPath)) {
         const entry = { path: normalizedPath };
         if (folder.name)
@@ -26834,10 +27112,10 @@ function getWorkspaceOutputPath(workspacePath, vscodeConfig) {
   const name = vscodeConfig?.output;
   if (name) {
     const filename = name.endsWith(".code-workspace") ? name : `${name}.code-workspace`;
-    return resolve7(workspacePath, filename);
+    return resolve8(workspacePath, filename);
   }
-  const dirName = basename3(resolve7(workspacePath));
-  return resolve7(workspacePath, `${dirName}.code-workspace`);
+  const dirName = basename3(resolve8(workspacePath));
+  return resolve8(workspacePath, `${dirName}.code-workspace`);
 }
 var DEFAULT_SETTINGS;
 var init_vscode_workspace = __esm(() => {
@@ -26847,9 +27125,9 @@ var init_vscode_workspace = __esm(() => {
 });
 
 // src/core/sync.ts
-import { existsSync as existsSync11, readFileSync, writeFileSync } from "node:fs";
-import { rm as rm3, unlink, rmdir, copyFile } from "node:fs/promises";
-import { join as join13, resolve as resolve8, dirname as dirname4, relative } from "node:path";
+import { existsSync as existsSync11, readFileSync, writeFileSync, lstatSync } from "node:fs";
+import { rm as rm4, unlink, rmdir, copyFile } from "node:fs/promises";
+import { join as join13, resolve as resolve9, dirname as dirname5, relative as relative2 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -26900,8 +27178,11 @@ async function selectivePurgeWorkspace(workspacePath, state, clients, options2)
         continue;
       }
       try {
-        if (filePath.endsWith("/")) {
-          await rm3(fullPath, { recursive: true, force: true });
+        const stats = lstatSync(fullPath.replace(/\/$/, ""));
+        if (stats.isSymbolicLink()) {
+          await unlink(fullPath.replace(/\/$/, ""));
+        } else if (filePath.endsWith("/")) {
+          await rm4(fullPath, { recursive: true, force: true });
         } else {
           await unlink(fullPath);
         }
@@ -26916,16 +27197,16 @@ async function selectivePurgeWorkspace(workspacePath, state, clients, options2)
   return result;
 }
 async function cleanupEmptyParents(workspacePath, filePath) {
-  let parentPath = dirname4(filePath);
+  let parentPath = dirname5(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
     const fullParentPath = join13(workspacePath, parentPath);
     if (!existsSync11(fullParentPath)) {
-      parentPath = dirname4(parentPath);
+      parentPath = dirname5(parentPath);
       continue;
     }
     try {
       await rmdir(fullParentPath);
-      parentPath = dirname4(parentPath);
+      parentPath = dirname5(parentPath);
     } catch {
       break;
     }
@@ -27032,11 +27313,11 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         if (file.source.startsWith("/")) {
           fullPath = file.source;
         } else if (file.source.startsWith("../")) {
-          fullPath = resolve8(file.source);
+          fullPath = resolve9(file.source);
         } else if (defaultSourcePath) {
           fullPath = join13(defaultSourcePath, file.source);
         } else {
-          fullPath = resolve8(file.source);
+          fullPath = resolve9(file.source);
         }
         if (!existsSync11(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
@@ -27065,7 +27346,7 @@ function collectSyncedPaths(copyResults, workspacePath, clients, clientMappings)
     if (copyResult.action !== "copied" && copyResult.action !== "generated") {
       continue;
     }
-    const relativePath = relative(workspacePath, copyResult.destination).replace(/\\/g, "/");
+    const relativePath = relative2(workspacePath, copyResult.destination).replace(/\\/g, "/");
     for (const client of clients) {
       const mapping = mappings[client];
       if (mapping.skillsPath && relativePath.startsWith(mapping.skillsPath)) {
@@ -27121,7 +27402,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
       success: true
     };
   }
-  const resolvedPath = resolve8(workspacePath, pluginSource);
+  const resolvedPath = resolve9(workspacePath, pluginSource);
   if (!existsSync11(resolvedPath)) {
     return {
       plugin: pluginSource,
@@ -27139,13 +27420,55 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
 async function validateAllPlugins(plugins, workspacePath, offline) {
   return Promise.all(plugins.map((plugin) => validatePlugin(plugin, workspacePath, offline)));
 }
-async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, clientMappings) {
+async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, clientMappings, syncMode = "symlink") {
   const copyResults = [];
   const mappings = clientMappings ?? CLIENT_MAPPINGS;
-  const { representativeClients } = deduplicateClientsByPath(clients, mappings);
-  for (const client of representativeClients) {
-    const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, { dryRun, ...skillNameMap && { skillNameMap }, ...clientMappings && { clientMappings } });
-    copyResults.push(...results);
+  const clientList = clients;
+  if (syncMode === "symlink") {
+    const { representativeClients } = deduplicateClientsByPath(clientList, mappings);
+    const canonicalRepresentative = representativeClients.find((c) => mappings[c]?.skillsPath === CANONICAL_SKILLS_PATH);
+    const needsCanonicalCopy = !canonicalRepresentative;
+    const nonUniversalClients = clientList.filter((c) => !isUniversalClient(c));
+    if (needsCanonicalCopy && nonUniversalClients.length > 0) {
+      const canonicalResults = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, "copilot", {
+        dryRun,
+        ...skillNameMap && { skillNameMap },
+        syncMode: "copy"
+      });
+      const skillResults = canonicalResults.filter((r) => r.destination.includes(CANONICAL_SKILLS_PATH) && r.action === "copied");
+      copyResults.push(...skillResults);
+    }
+    for (const representative of representativeClients) {
+      if (isUniversalClient(representative)) {
+        const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, representative, {
+          dryRun,
+          ...skillNameMap && { skillNameMap },
+          ...clientMappings && { clientMappings },
+          syncMode: "copy"
+        });
+        copyResults.push(...results);
+      } else {
+        const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, representative, {
+          dryRun,
+          ...skillNameMap && { skillNameMap },
+          ...clientMappings && { clientMappings },
+          syncMode: "symlink",
+          canonicalSkillsPath: CANONICAL_SKILLS_PATH
+        });
+        copyResults.push(...results);
+      }
+    }
+  } else {
+    const { representativeClients } = deduplicateClientsByPath(clientList, mappings);
+    for (const client of representativeClients) {
+      const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, {
+        dryRun,
+        ...skillNameMap && { skillNameMap },
+        ...clientMappings && { clientMappings },
+        syncMode: "copy"
+      });
+      copyResults.push(...results);
+    }
   }
   const hasFailures = copyResults.some((r) => r.action === "failed");
   return {
@@ -27155,11 +27478,11 @@ async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryR
     copyResults
   };
 }
-async function collectAllSkills(validatedPlugins) {
+async function collectAllSkills(validatedPlugins, disabledSkills) {
   const allSkills = [];
   for (const plugin of validatedPlugins) {
     const pluginName = plugin.pluginName ?? await getPluginName(plugin.resolved);
-    const skills = await collectPluginSkills(plugin.resolved, plugin.plugin);
+    const skills = await collectPluginSkills(plugin.resolved, plugin.plugin, disabledSkills, pluginName);
     for (const skill of skills) {
       allSkills.push({
         folderName: skill.folderName,
@@ -27263,6 +27586,7 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
       };
     }
   }
+  await ensureMarketplacesRegistered(config.plugins);
   const validatedPlugins = await validateAllPlugins(config.plugins, workspacePath, offline);
   let validatedWorkspaceSource = null;
   if (config.workspace?.source) {
@@ -27307,11 +27631,13 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
       partialSync: !!options2.clients
     });
   }
-  const allSkills = await collectAllSkills(validPlugins);
+  const disabledSkillsSet = new Set(config.disabledSkills ?? []);
+  const allSkills = await collectAllSkills(validPlugins, disabledSkillsSet);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
+  const syncMode = config.syncMode ?? "symlink";
   const pluginResults = await Promise.all(validPlugins.map((validatedPlugin) => {
     const skillNameMap = pluginSkillMaps.get(validatedPlugin.resolved);
-    return copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap);
+    return copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, undefined, syncMode);
   }));
   let workspaceFileResults = [];
   if (config.workspace) {
@@ -27437,7 +27763,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   };
 }
 async function syncUserWorkspace(options2 = {}) {
-  const homeDir = resolve8(getHomeDir());
+  const homeDir = resolve9(getHomeDir());
   const config = await getUserWorkspaceConfig();
   if (!config) {
     return {
@@ -27451,6 +27777,7 @@ async function syncUserWorkspace(options2 = {}) {
   }
   const clients = config.clients;
   const { offline = false, dryRun = false } = options2;
+  await ensureMarketplacesRegistered(config.plugins);
   const validatedPlugins = await validateAllPlugins(config.plugins, homeDir, offline);
   const failedValidations = validatedPlugins.filter((v) => !v.success);
   const validPlugins = validatedPlugins.filter((v) => v.success);
@@ -27473,11 +27800,13 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   if (!dryRun) {
     await selectivePurgeWorkspace(homeDir, previousState, clients);
   }
-  const allSkills = await collectAllSkills(validPlugins);
+  const disabledSkillsSet = new Set(config.disabledSkills ?? []);
+  const allSkills = await collectAllSkills(validPlugins, disabledSkillsSet);
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
+  const syncMode = config.syncMode ?? "symlink";
   const pluginResults = await Promise.all(validPlugins.map((vp) => {
     const skillNameMap = pluginSkillMaps.get(vp.resolved);
-    return copyValidatedPlugin(vp, homeDir, clients, dryRun, skillNameMap, USER_CLIENT_MAPPINGS);
+    return copyValidatedPlugin(vp, homeDir, clients, dryRun, skillNameMap, USER_CLIENT_MAPPINGS, syncMode);
   }));
   let totalCopied = 0;
   let totalFailed = 0;
@@ -27631,12 +27960,12 @@ var init_github_fetch = __esm(() => {
 });
 
 // src/core/workspace.ts
-import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile7, copyFile as copyFile2 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile7, copyFile as copyFile2 } from "node:fs/promises";
 import { existsSync as existsSync13 } from "node:fs";
-import { join as join15, resolve as resolve9, dirname as dirname5, relative as relative2, sep as sep2, isAbsolute as isAbsolute3 } from "node:path";
+import { join as join15, resolve as resolve10, dirname as dirname6, relative as relative3, sep as sep2, isAbsolute as isAbsolute3 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
-  const absoluteTarget = resolve9(targetPath);
+  const absoluteTarget = resolve10(targetPath);
   const configDir = join15(absoluteTarget, CONFIG_DIR);
   const configPath = join15(configDir, WORKSPACE_CONFIG_FILE);
   if (existsSync13(configPath)) {
@@ -27644,13 +27973,13 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   Found existing ${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`);
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentFileDir = dirname5(currentFilePath);
+  const currentFileDir = dirname6(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
   const defaultTemplatePath = isProduction ? join15(currentFileDir, "templates", "default") : join15(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   try {
-    await mkdir7(absoluteTarget, { recursive: true });
-    await mkdir7(configDir, { recursive: true });
+    await mkdir8(absoluteTarget, { recursive: true });
+    await mkdir8(configDir, { recursive: true });
     let workspaceYamlContent;
     let sourceDir;
     if (options2.from) {
@@ -27682,7 +28011,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
-        const fromPath = resolve9(options2.from);
+        const fromPath = resolve10(options2.from);
         if (!existsSync13(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
@@ -27704,9 +28033,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else {
           sourceYamlPath = fromPath;
-          const parentDir = dirname5(fromPath);
+          const parentDir = dirname6(fromPath);
           if (parentDir.endsWith(CONFIG_DIR)) {
-            sourceDir = dirname5(parentDir);
+            sourceDir = dirname6(parentDir);
           } else {
             sourceDir = parentDir;
           }
@@ -27718,7 +28047,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           if (workspace?.source) {
             const source = workspace.source;
             if (!isGitHubUrl(source) && !isAbsolute3(source)) {
-              workspace.source = resolve9(sourceDir, source);
+              workspace.source = resolve10(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
           }
@@ -27834,7 +28163,7 @@ Syncing plugins...`);
     if (targetPath !== ".") {
       console.log(`
 Next steps:`);
-      console.log(`  cd ${relative2(process.cwd(), absoluteTarget)}`);
+      console.log(`  cd ${relative3(process.cwd(), absoluteTarget)}`);
     }
     return {
       path: absoluteTarget,
@@ -28045,12 +28374,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve11, reject) {
+      return new Promise(function(resolve13, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve11(is);
+            resolve13(is);
           }
         });
       });
@@ -28112,27 +28441,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve11, reject) => {
+    const step = (i2) => new Promise((resolve13, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve11(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve13(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve11(subStep(p, i2, 0));
+      resolve13(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve11, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve13, reject) => {
       if (ii === pathExt.length)
-        return resolve11(step(i2 + 1));
+        return resolve13(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve11(p + ext);
+            return resolve13(p + ext);
         }
-        return resolve11(subStep(p, i2, ii + 1));
+        return resolve13(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -28173,8 +28502,8 @@ var require_which = __commonJS((exports, module) => {
 var require_path_key = __commonJS((exports, module) => {
   var pathKey = (options2 = {}) => {
     const environment = options2.env || process.env;
-    const platform = options2.platform || process.platform;
-    if (platform !== "win32") {
+    const platform2 = options2.platform || process.platform;
+    if (platform2 !== "win32") {
       return "PATH";
     }
     return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
@@ -28250,8 +28579,8 @@ var require_shebang_regex = __commonJS((exports, module) => {
 // node_modules/shebang-command/index.js
 var require_shebang_command = __commonJS((exports, module) => {
   var shebangRegex = require_shebang_regex();
-  module.exports = (string3 = "") => {
-    const match = string3.match(shebangRegex);
+  module.exports = (string4 = "") => {
+    const match = string4.match(shebangRegex);
     if (!match) {
       return null;
     }
@@ -28268,12 +28597,12 @@ var require_shebang_command = __commonJS((exports, module) => {
 var require_readShebang = __commonJS((exports, module) => {
   var fs = __require("fs");
   var shebangCommand = require_shebang_command();
-  function readShebang(command3) {
+  function readShebang(command4) {
     const size = 150;
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs.openSync(command3, "r");
+      fd = fs.openSync(command4, "r");
       fs.readSync(fd, buffer, 0, size, 0);
       fs.closeSync(fd);
     } catch (e) {}
@@ -28319,7 +28648,7 @@ var require_parse5 = __commonJS((exports, module) => {
     }
     return parsed;
   }
-  function parse2(command3, args, options2) {
+  function parse2(command4, args, options2) {
     if (args && !Array.isArray(args)) {
       options2 = args;
       args = null;
@@ -28327,12 +28656,12 @@ var require_parse5 = __commonJS((exports, module) => {
     args = args ? args.slice(0) : [];
     options2 = Object.assign({}, options2);
     const parsed = {
-      command: command3,
+      command: command4,
       args,
       options: options2,
       file: undefined,
       original: {
-        command: command3,
+        command: command4,
         args
       }
     };
@@ -28393,14 +28722,14 @@ var require_cross_spawn = __commonJS((exports, module) => {
   var cp2 = __require("child_process");
   var parse2 = require_parse5();
   var enoent = require_enoent();
-  function spawn2(command3, args, options2) {
-    const parsed = parse2(command3, args, options2);
+  function spawn2(command4, args, options2) {
+    const parsed = parse2(command4, args, options2);
     const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
     enoent.hookChildProcess(spawned, parsed);
     return spawned;
   }
-  function spawnSync(command3, args, options2) {
-    const parsed = parse2(command3, args, options2);
+  function spawnSync(command4, args, options2) {
+    const parsed = parse2(command4, args, options2);
     const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
     return result;
@@ -28431,9 +28760,9 @@ function stripFinalNewline(input) {
 function pathKey(options2 = {}) {
   const {
     env: env2 = process.env,
-    platform = process.platform
+    platform: platform2 = process.platform
   } = options2;
-  if (platform !== "win32") {
+  if (platform2 !== "win32") {
     return "PATH";
   }
   return Object.keys(env2).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
@@ -28943,7 +29272,7 @@ var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription,
   error,
   signal,
   exitCode,
-  command: command3,
+  command: command4,
   escapedCommand,
   timedOut,
   isCanceled,
@@ -28955,7 +29284,7 @@ var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription,
   const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
   const errorCode = error && error.code;
   const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
-  const execaMessage = `Command ${prefix}: ${command3}`;
+  const execaMessage = `Command ${prefix}: ${command4}`;
   const isError = Object.prototype.toString.call(error) === "[object Error]";
   const shortMessage = isError ? `${execaMessage}
 ${error.message}` : execaMessage;
@@ -28968,7 +29297,7 @@ ${error.message}` : execaMessage;
     error = new Error(message);
   }
   error.shortMessage = shortMessage;
-  error.command = command3;
+  error.command = command4;
   error.escapedCommand = escapedCommand;
   error.exitCode = exitCode;
   error.signal = signal;
@@ -29265,7 +29594,7 @@ var DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill = (kill, signal = "SIGTERM", options
     return spawnedPromise;
   }
   let timeoutId;
-  const timeoutPromise = new Promise((resolve11, reject) => {
+  const timeoutPromise = new Promise((resolve13, reject) => {
     timeoutId = setTimeout(() => {
       timeoutKill(spawned, killSignal, reject);
     }, timeout);
@@ -29655,9 +29984,9 @@ var nativePromisePrototype, descriptors, mergePromise = (spawned, promise) => {
     const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor.value, promise(), args) : descriptor.value.bind(promise);
     Reflect.defineProperty(spawned, property, { ...descriptor, value });
   }
-}, getSpawnedPromise = (spawned) => new Promise((resolve11, reject) => {
+}, getSpawnedPromise = (spawned) => new Promise((resolve13, reject) => {
   spawned.on("exit", (exitCode, signal) => {
-    resolve11({ exitCode, signal });
+    resolve13({ exitCode, signal });
   });
   spawned.on("error", (error) => {
     reject(error);
@@ -29758,7 +30087,7 @@ import childProcess from "node:child_process";
 import process7 from "node:process";
 function execa(file, args, options2) {
   const parsed = handleArguments(file, args, options2);
-  const command3 = joinCommand(file, args);
+  const command4 = joinCommand(file, args);
   const escapedCommand = getEscapedCommand(file, args);
   logCommand(escapedCommand, parsed.options);
   validateTimeout(parsed.options);
@@ -29772,7 +30101,7 @@ function execa(file, args, options2) {
       stdout: "",
       stderr: "",
       all: "",
-      command: command3,
+      command: command4,
       escapedCommand,
       parsed,
       timedOut: false,
@@ -29801,7 +30130,7 @@ function execa(file, args, options2) {
         stdout,
         stderr,
         all,
-        command: command3,
+        command: command4,
         escapedCommand,
         parsed,
         timedOut,
@@ -29814,7 +30143,7 @@ function execa(file, args, options2) {
       throw returnedError;
     }
     return {
-      command: command3,
+      command: command4,
       escapedCommand,
       exitCode: 0,
       stdout,
@@ -29835,7 +30164,7 @@ function execa(file, args, options2) {
 }
 function execaSync(file, args, options2) {
   const parsed = handleArguments(file, args, options2);
-  const command3 = joinCommand(file, args);
+  const command4 = joinCommand(file, args);
   const escapedCommand = getEscapedCommand(file, args);
   logCommand(escapedCommand, parsed.options);
   const input = handleInputSync(parsed.options);
@@ -29848,7 +30177,7 @@ function execaSync(file, args, options2) {
       stdout: "",
       stderr: "",
       all: "",
-      command: command3,
+      command: command4,
       escapedCommand,
       parsed,
       timedOut: false,
@@ -29865,7 +30194,7 @@ function execaSync(file, args, options2) {
       error: result.error,
       signal: result.signal,
       exitCode: result.status,
-      command: command3,
+      command: command4,
       escapedCommand,
       parsed,
       timedOut: result.error && result.error.code === "ETIMEDOUT",
@@ -29878,7 +30207,7 @@ function execaSync(file, args, options2) {
     throw error;
   }
   return {
-    command: command3,
+    command: command4,
     escapedCommand,
     exitCode: 0,
     stdout,
@@ -29973,7 +30302,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "0.17.2",
+    version: "0.20.0",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -30042,13 +30371,13 @@ var init_package = __esm(() => {
 });
 
 // src/cli/update-check.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import { join as join20 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 async function getCachedUpdateInfo(path3) {
-  const filePath = path3 ?? join19(getHomeDir(), CONFIG_DIR, CACHE_FILE);
+  const filePath = path3 ?? join20(getHomeDir(), CONFIG_DIR, CACHE_FILE);
   try {
-    const raw = await readFile13(filePath, "utf-8");
+    const raw = await readFile14(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -30084,8 +30413,8 @@ function buildNotice(currentVersion, latestVersion) {
   Run \`allagents self update\` to upgrade.`;
 }
 function backgroundUpdateCheck() {
-  const dir = join19(getHomeDir(), CONFIG_DIR);
-  const filePath = join19(dir, CACHE_FILE);
+  const dir = join20(getHomeDir(), CONFIG_DIR);
+  const filePath = join20(dir, CACHE_FILE);
   const script = `
     const https = require('https');
     const fs = require('fs');
@@ -30136,17 +30465,17 @@ var require_picocolors = __commonJS((exports, module) => {
   var env2 = p.env || {};
   var isColorSupported = !(!!env2.NO_COLOR || argv.includes("--no-color")) && (!!env2.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env2.TERM !== "dumb" || !!env2.CI);
   var formatter = (open, close, replace = open) => (input) => {
-    let string3 = "" + input, index = string3.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string3, close, replace, index) + close : open + string3 + close;
+    let string4 = "" + input, index = string4.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string4, close, replace, index) + close : open + string4 + close;
   };
-  var replaceClose = (string3, close, replace, index) => {
+  var replaceClose = (string4, close, replace, index) => {
     let result = "", cursor = 0;
     do {
-      result += string3.substring(cursor, index) + replace;
+      result += string4.substring(cursor, index) + replace;
       cursor = index + close.length;
-      index = string3.indexOf(close, cursor);
+      index = string4.indexOf(close, cursor);
     } while (~index);
-    return result + string3.substring(cursor);
+    return result + string4.substring(cursor);
   };
   var createColors = (enabled = isColorSupported) => {
     let f = enabled ? formatter : () => String;
@@ -31921,15 +32250,15 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync17 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { join as join21 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
   if (cachedContext) {
     return cachedContext;
   }
-  const configPath = join20(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync17(configPath) && !isUserConfigPath(cwd);
+  const configPath = join21(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const hasWorkspace = existsSync18(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -32563,7 +32892,7 @@ __export(exports_wizard, {
   runWizard: () => runWizard,
   buildMenuOptions: () => buildMenuOptions
 });
-import { relative as relative3 } from "node:path";
+import { relative as relative4 } from "node:path";
 function buildMenuOptions(context) {
   const options2 = [];
   if (!context.hasWorkspace) {
@@ -32598,7 +32927,7 @@ function buildMenuOptions(context) {
 function buildSummary(context) {
   const lines = [];
   if (context.hasWorkspace && context.workspacePath) {
-    const relPath = relative3(process.cwd(), context.workspacePath) || ".";
+    const relPath = relative4(process.cwd(), context.workspacePath) || ".";
     lines.push(`Workspace: ${relPath}`);
     lines.push(`Project plugins: ${context.projectPluginCount}`);
   } else {
@@ -32686,7 +33015,7 @@ var init_wizard = __esm(() => {
 });
 
 // src/cli/index.ts
-var import_cmd_ts5 = __toESM(require_cjs(), 1);
+var import_cmd_ts6 = __toESM(require_cjs(), 1);
 
 // src/cli/help.ts
 var import_cmd_ts = __toESM(require_cjs(), 1);
@@ -32737,7 +33066,7 @@ init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
 import { existsSync as existsSync16 } from "node:fs";
-import { join as join18, resolve as resolve10 } from "node:path";
+import { join as join18, resolve as resolve11 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -33304,7 +33633,7 @@ var repoAddCmd = import_cmd_ts2.command({
   },
   handler: async ({ path: repoPath, description }) => {
     try {
-      const resolvedPath = resolve10(process.cwd(), repoPath);
+      const resolvedPath = resolve11(process.cwd(), repoPath);
       const remote = await detectRemote(resolvedPath);
       const result = await addRepository(repoPath, {
         source: remote?.source,
@@ -33459,7 +33788,7 @@ init_marketplace();
 init_sync();
 init_workspace_modify();
 init_user_workspace();
-var import_cmd_ts3 = __toESM(require_cjs(), 1);
+var import_cmd_ts4 = __toESM(require_cjs(), 1);
 
 // src/cli/metadata/plugin.ts
 var marketplaceListMeta = {
@@ -33626,6 +33955,474 @@ var pluginUninstallMeta = {
   }
 };
 
+// src/cli/commands/plugin-skills.ts
+init_sync();
+init_workspace_modify();
+init_user_workspace();
+var import_cmd_ts3 = __toESM(require_cjs(), 1);
+
+// src/core/skills.ts
+init_js_yaml();
+init_constants();
+init_plugin();
+init_plugin_path();
+init_marketplace();
+import { existsSync as existsSync17 } from "node:fs";
+import { readFile as readFile13, readdir as readdir4 } from "node:fs/promises";
+import { join as join19, resolve as resolve12 } from "node:path";
+async function resolvePluginPath(pluginSource, workspacePath) {
+  if (isPluginSpec(pluginSource)) {
+    const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource);
+    return resolved2.success ? resolved2.path ?? null : null;
+  }
+  if (isGitHubUrl(pluginSource)) {
+    const parsed = parseGitHubUrl(pluginSource);
+    const result = await fetchPlugin(pluginSource, {
+      offline: true,
+      ...parsed?.branch && { branch: parsed.branch }
+    });
+    if (!result.success)
+      return null;
+    return parsed?.subpath ? join19(result.cachePath, parsed.subpath) : result.cachePath;
+  }
+  const resolved = resolve12(workspacePath, pluginSource);
+  return existsSync17(resolved) ? resolved : null;
+}
+async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
+  const configPath = join19(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync17(configPath)) {
+    return [];
+  }
+  const content = await readFile13(configPath, "utf-8");
+  const config = load(content);
+  const disabledSkills = new Set(config.disabledSkills ?? []);
+  const skills = [];
+  for (const pluginSource of config.plugins) {
+    const pluginPath = await resolvePluginPath(pluginSource, workspacePath);
+    if (!pluginPath)
+      continue;
+    const pluginName = await getPluginName(pluginPath);
+    const skillsDir = join19(pluginPath, "skills");
+    if (!existsSync17(skillsDir))
+      continue;
+    const entries = await readdir4(skillsDir, { withFileTypes: true });
+    const skillDirs = entries.filter((e) => e.isDirectory());
+    for (const entry of skillDirs) {
+      const skillKey = `${pluginName}:${entry.name}`;
+      skills.push({
+        name: entry.name,
+        pluginName,
+        pluginSource,
+        path: join19(skillsDir, entry.name),
+        disabled: disabledSkills.has(skillKey)
+      });
+    }
+  }
+  return skills;
+}
+async function findSkillByName(skillName, workspacePath = process.cwd()) {
+  const allSkills = await getAllSkillsFromPlugins(workspacePath);
+  return allSkills.filter((s) => s.name === skillName);
+}
+
+// src/cli/metadata/plugin-skills.ts
+var skillsListMeta = {
+  command: "plugin skills list",
+  description: "List all skills from installed plugins",
+  whenToUse: "To see available skills and their enabled/disabled status",
+  examples: [
+    "allagents plugin skills list",
+    "allagents plugin skills list --scope user"
+  ],
+  expectedOutput: "Lists skills grouped by plugin with enabled/disabled status",
+  options: [
+    { flag: "--scope", short: "-s", type: "string", description: 'Scope: "project" (default) or "user"' }
+  ],
+  outputSchema: {
+    skills: [{ name: "string", plugin: "string", disabled: "boolean" }]
+  }
+};
+var skillsRemoveMeta = {
+  command: "plugin skills remove",
+  description: "Disable a skill (exclude from sync)",
+  whenToUse: "To prevent a specific skill from being synced to your workspace",
+  examples: [
+    "allagents plugin skills remove brainstorming",
+    "allagents plugin skills remove brainstorming --plugin superpowers",
+    "allagents plugin skills remove brainstorming --scope user"
+  ],
+  expectedOutput: "Confirms skill was disabled and runs sync",
+  positionals: [
+    { name: "skill", type: "string", required: true, description: "Skill name to disable" }
+  ],
+  options: [
+    { flag: "--scope", short: "-s", type: "string", description: 'Scope: "project" (default) or "user"' },
+    { flag: "--plugin", short: "-p", type: "string", description: "Plugin name (required if skill exists in multiple plugins)" }
+  ],
+  outputSchema: {
+    skill: "string",
+    plugin: "string",
+    syncResult: { copied: "number", failed: "number" }
+  }
+};
+var skillsAddMeta = {
+  command: "plugin skills add",
+  description: "Re-enable a previously disabled skill",
+  whenToUse: "To re-enable a skill that was previously disabled",
+  examples: [
+    "allagents plugin skills add brainstorming",
+    "allagents plugin skills add brainstorming --plugin superpowers"
+  ],
+  expectedOutput: "Confirms skill was enabled and runs sync",
+  positionals: [
+    { name: "skill", type: "string", required: true, description: "Skill name to enable" }
+  ],
+  options: [
+    { flag: "--scope", short: "-s", type: "string", description: 'Scope: "project" (default) or "user"' },
+    { flag: "--plugin", short: "-p", type: "string", description: "Plugin name (required if skill exists in multiple plugins)" }
+  ],
+  outputSchema: {
+    skill: "string",
+    plugin: "string",
+    syncResult: { copied: "number", failed: "number" }
+  }
+};
+
+// src/cli/commands/plugin-skills.ts
+init_constants();
+function groupSkillsByPlugin(skills) {
+  const grouped = new Map;
+  for (const skill of skills) {
+    const existing = grouped.get(skill.pluginName);
+    if (existing) {
+      existing.skills.push({ name: skill.name, disabled: skill.disabled });
+    } else {
+      grouped.set(skill.pluginName, {
+        source: skill.pluginSource,
+        skills: [{ name: skill.name, disabled: skill.disabled }]
+      });
+    }
+  }
+  return grouped;
+}
+var listCmd = import_cmd_ts3.command({
+  name: "list",
+  description: buildDescription(skillsListMeta),
+  args: {
+    scope: import_cmd_ts3.option({
+      type: import_cmd_ts3.optional(import_cmd_ts3.string),
+      long: "scope",
+      short: "s",
+      description: 'Scope: "project" (default) or "user"'
+    })
+  },
+  handler: async ({ scope }) => {
+    try {
+      const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
+      const workspacePath = isUser ? getHomeDir() : process.cwd();
+      const skills = await getAllSkillsFromPlugins(workspacePath);
+      if (isJsonMode()) {
+        jsonOutput({
+          success: true,
+          command: "plugin skills list",
+          data: {
+            scope: isUser ? "user" : "project",
+            skills: skills.map((s) => ({
+              name: s.name,
+              plugin: s.pluginName,
+              disabled: s.disabled
+            }))
+          }
+        });
+        return;
+      }
+      if (skills.length === 0) {
+        console.log("No skills found. Install a plugin first with:");
+        console.log("  allagents plugin install <plugin>");
+        return;
+      }
+      const grouped = groupSkillsByPlugin(skills);
+      for (const [pluginName, data] of grouped) {
+        console.log(`
+${pluginName} (${data.source}):`);
+        for (const skill of data.skills) {
+          const icon = skill.disabled ? "✗" : "✓";
+          const status = skill.disabled ? " (disabled)" : "";
+          console.log(`  ${icon} ${skill.name}${status}`);
+        }
+      }
+      console.log();
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills list", error: error.message });
+          process.exit(1);
+        }
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+var removeCmd = import_cmd_ts3.command({
+  name: "remove",
+  description: buildDescription(skillsRemoveMeta),
+  args: {
+    skill: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "skill" }),
+    scope: import_cmd_ts3.option({
+      type: import_cmd_ts3.optional(import_cmd_ts3.string),
+      long: "scope",
+      short: "s",
+      description: 'Scope: "project" (default) or "user"'
+    }),
+    plugin: import_cmd_ts3.option({
+      type: import_cmd_ts3.optional(import_cmd_ts3.string),
+      long: "plugin",
+      short: "p",
+      description: "Plugin name (required if skill exists in multiple plugins)"
+    })
+  },
+  handler: async ({ skill, scope, plugin }) => {
+    try {
+      const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
+      const workspacePath = isUser ? getHomeDir() : process.cwd();
+      const matches = await findSkillByName(skill, workspacePath);
+      if (matches.length === 0) {
+        const allSkills = await getAllSkillsFromPlugins(workspacePath);
+        const skillNames = [...new Set(allSkills.map((s) => s.name))].join(", ");
+        const error = `Skill '${skill}' not found in any installed plugin.
+
+Available skills: ${skillNames || "none"}`;
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills remove", error });
+          process.exit(1);
+        }
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+      let targetSkill = matches[0];
+      if (!targetSkill) {
+        throw new Error("Unexpected empty matches array");
+      }
+      if (matches.length > 1) {
+        if (!plugin) {
+          const pluginList = matches.map((m) => `  - ${m.pluginName} (${m.pluginSource})`).join(`
+`);
+          const error = `'${skill}' exists in multiple plugins:
+${pluginList}
+
+Use --plugin to specify: allagents plugin skills remove ${skill} --plugin <name>`;
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: "plugin skills remove", error });
+            process.exit(1);
+          }
+          console.error(`Error: ${error}`);
+          process.exit(1);
+        }
+        const filtered = matches.find((m) => m.pluginName === plugin);
+        if (!filtered) {
+          const error = `Plugin '${plugin}' not found. Installed plugins: ${matches.map((m) => m.pluginName).join(", ")}`;
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: "plugin skills remove", error });
+            process.exit(1);
+          }
+          console.error(`Error: ${error}`);
+          process.exit(1);
+        }
+        targetSkill = filtered;
+      }
+      if (targetSkill.disabled) {
+        const msg = `Skill '${skill}' is already disabled.`;
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills remove", error: msg });
+          process.exit(1);
+        }
+        console.log(msg);
+        return;
+      }
+      const skillKey = `${targetSkill.pluginName}:${skill}`;
+      const result = isUser ? await addUserDisabledSkill(skillKey) : await addDisabledSkill(skillKey, workspacePath);
+      if (!result.success) {
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills remove", error: result.error ?? "Unknown error" });
+          process.exit(1);
+        }
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      if (!isJsonMode()) {
+        console.log(`✓ Disabled skill: ${skill} (${targetSkill.pluginName})`);
+        console.log(`
+Syncing workspace...
+`);
+      }
+      const syncResult = isUser ? await syncUserWorkspace() : await syncWorkspace(workspacePath);
+      if (isJsonMode()) {
+        jsonOutput({
+          success: syncResult.success,
+          command: "plugin skills remove",
+          data: {
+            skill,
+            plugin: targetSkill.pluginName,
+            syncResult: {
+              copied: syncResult.totalCopied,
+              failed: syncResult.totalFailed
+            }
+          }
+        });
+        if (!syncResult.success)
+          process.exit(1);
+        return;
+      }
+      console.log("Sync complete.");
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills remove", error: error.message });
+          process.exit(1);
+        }
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+var addCmd = import_cmd_ts3.command({
+  name: "add",
+  description: buildDescription(skillsAddMeta),
+  args: {
+    skill: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "skill" }),
+    scope: import_cmd_ts3.option({
+      type: import_cmd_ts3.optional(import_cmd_ts3.string),
+      long: "scope",
+      short: "s",
+      description: 'Scope: "project" (default) or "user"'
+    }),
+    plugin: import_cmd_ts3.option({
+      type: import_cmd_ts3.optional(import_cmd_ts3.string),
+      long: "plugin",
+      short: "p",
+      description: "Plugin name (required if skill exists in multiple plugins)"
+    })
+  },
+  handler: async ({ skill, scope, plugin }) => {
+    try {
+      const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
+      const workspacePath = isUser ? getHomeDir() : process.cwd();
+      const matches = await findSkillByName(skill, workspacePath);
+      if (matches.length === 0) {
+        const allSkills = await getAllSkillsFromPlugins(workspacePath);
+        const skillNames = [...new Set(allSkills.map((s) => s.name))].join(", ");
+        const error = `Skill '${skill}' not found in any installed plugin.
+
+Available skills: ${skillNames || "none"}`;
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills add", error });
+          process.exit(1);
+        }
+        console.error(`Error: ${error}`);
+        process.exit(1);
+      }
+      let targetSkill = matches[0];
+      if (!targetSkill) {
+        throw new Error("Unexpected empty matches array");
+      }
+      if (matches.length > 1) {
+        if (!plugin) {
+          const pluginList = matches.map((m) => `  - ${m.pluginName} (${m.pluginSource})`).join(`
+`);
+          const error = `'${skill}' exists in multiple plugins:
+${pluginList}
+
+Use --plugin to specify: allagents plugin skills add ${skill} --plugin <name>`;
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: "plugin skills add", error });
+            process.exit(1);
+          }
+          console.error(`Error: ${error}`);
+          process.exit(1);
+        }
+        const filtered = matches.find((m) => m.pluginName === plugin);
+        if (!filtered) {
+          const error = `Plugin '${plugin}' not found. Installed plugins: ${matches.map((m) => m.pluginName).join(", ")}`;
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: "plugin skills add", error });
+            process.exit(1);
+          }
+          console.error(`Error: ${error}`);
+          process.exit(1);
+        }
+        targetSkill = filtered;
+      }
+      if (!targetSkill.disabled) {
+        const msg = `Skill '${skill}' is already enabled.`;
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills add", error: msg });
+          process.exit(1);
+        }
+        console.log(msg);
+        return;
+      }
+      const skillKey = `${targetSkill.pluginName}:${skill}`;
+      const result = isUser ? await removeUserDisabledSkill(skillKey) : await removeDisabledSkill(skillKey, workspacePath);
+      if (!result.success) {
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills add", error: result.error ?? "Unknown error" });
+          process.exit(1);
+        }
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      if (!isJsonMode()) {
+        console.log(`✓ Enabled skill: ${skill} (${targetSkill.pluginName})`);
+        console.log(`
+Syncing workspace...
+`);
+      }
+      const syncResult = isUser ? await syncUserWorkspace() : await syncWorkspace(workspacePath);
+      if (isJsonMode()) {
+        jsonOutput({
+          success: syncResult.success,
+          command: "plugin skills add",
+          data: {
+            skill,
+            plugin: targetSkill.pluginName,
+            syncResult: {
+              copied: syncResult.totalCopied,
+              failed: syncResult.totalFailed
+            }
+          }
+        });
+        if (!syncResult.success)
+          process.exit(1);
+        return;
+      }
+      console.log("Sync complete.");
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills add", error: error.message });
+          process.exit(1);
+        }
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+var skillsCmd = conciseSubcommands({
+  name: "skills",
+  description: "Manage individual skills from plugins",
+  cmds: {
+    list: listCmd,
+    remove: removeCmd,
+    add: addCmd
+  }
+});
+
 // src/cli/commands/plugin.ts
 function buildSyncData2(result) {
   return {
@@ -33745,7 +34542,7 @@ User sync complete:`);
   }
   return { ok: result.success && result.totalFailed === 0, syncData };
 }
-var marketplaceListCmd = import_cmd_ts3.command({
+var marketplaceListCmd = import_cmd_ts4.command({
   name: "list",
   description: buildDescription(marketplaceListMeta),
   args: {},
@@ -33766,11 +34563,9 @@ var marketplaceListCmd = import_cmd_ts3.command({
         console.log("Add a marketplace with:");
         console.log(`  allagents plugin marketplace add <source>
 `);
-        console.log("Well-known marketplaces:");
-        const wellKnown = getWellKnownMarketplaces();
-        for (const [name, repo] of Object.entries(wellKnown)) {
-          console.log(`  ${name} → ${repo}`);
-        }
+        console.log("Examples:");
+        console.log("  allagents plugin marketplace add owner/repo");
+        console.log("  allagents plugin marketplace add https://github.com/owner/repo");
         return;
       }
       console.log(`Registered marketplaces:
@@ -33798,13 +34593,13 @@ var marketplaceListCmd = import_cmd_ts3.command({
     }
   }
 });
-var marketplaceAddCmd = import_cmd_ts3.command({
+var marketplaceAddCmd = import_cmd_ts4.command({
   name: "add",
   description: buildDescription(marketplaceAddMeta),
   args: {
-    source: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "source" }),
-    name: import_cmd_ts3.option({ type: import_cmd_ts3.optional(import_cmd_ts3.string), long: "name", short: "n", description: "Custom name for the marketplace" }),
-    branch: import_cmd_ts3.option({ type: import_cmd_ts3.optional(import_cmd_ts3.string), long: "branch", short: "b", description: "Branch to checkout after cloning" })
+    source: import_cmd_ts4.positional({ type: import_cmd_ts4.string, displayName: "source" }),
+    name: import_cmd_ts4.option({ type: import_cmd_ts4.optional(import_cmd_ts4.string), long: "name", short: "n", description: "Custom name for the marketplace" }),
+    branch: import_cmd_ts4.option({ type: import_cmd_ts4.optional(import_cmd_ts4.string), long: "branch", short: "b", description: "Branch to checkout after cloning" })
   },
   handler: async ({ source, name, branch }) => {
     try {
@@ -33849,11 +34644,11 @@ Error: ${result.error}`);
     }
   }
 });
-var marketplaceRemoveCmd = import_cmd_ts3.command({
+var marketplaceRemoveCmd = import_cmd_ts4.command({
   name: "remove",
   description: buildDescription(marketplaceRemoveMeta),
   args: {
-    name: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "name" })
+    name: import_cmd_ts4.positional({ type: import_cmd_ts4.string, displayName: "name" })
   },
   handler: async ({ name }) => {
     try {
@@ -33877,14 +34672,13 @@ var marketplaceRemoveCmd = import_cmd_ts3.command({
         });
         return;
       }
-      console.log(`✓ Marketplace '${name}' removed from registry`);
+      console.log(`✓ Marketplace '${name}' removed`);
       if (result.removedUserPlugins && result.removedUserPlugins.length > 0) {
         console.log(`  Removed ${result.removedUserPlugins.length} user plugin(s):`);
         for (const p of result.removedUserPlugins) {
           console.log(`    - ${p}`);
         }
       }
-      console.log(`  Note: Files at ${result.marketplace?.path} were not deleted`);
     } catch (error) {
       if (error instanceof Error) {
         if (isJsonMode()) {
@@ -33898,11 +34692,11 @@ var marketplaceRemoveCmd = import_cmd_ts3.command({
     }
   }
 });
-var marketplaceUpdateCmd = import_cmd_ts3.command({
+var marketplaceUpdateCmd = import_cmd_ts4.command({
   name: "update",
   description: buildDescription(marketplaceUpdateMeta),
   args: {
-    name: import_cmd_ts3.positional({ type: import_cmd_ts3.optional(import_cmd_ts3.string), displayName: "name" })
+    name: import_cmd_ts4.positional({ type: import_cmd_ts4.optional(import_cmd_ts4.string), displayName: "name" })
   },
   handler: async ({ name }) => {
     try {
@@ -33968,11 +34762,11 @@ var marketplaceCmd = conciseSubcommands({
     update: marketplaceUpdateCmd
   }
 });
-var pluginListCmd = import_cmd_ts3.command({
+var pluginListCmd = import_cmd_ts4.command({
   name: "list",
   description: buildDescription(pluginListMeta),
   args: {
-    marketplace: import_cmd_ts3.positional({ type: import_cmd_ts3.optional(import_cmd_ts3.string), displayName: "marketplace" })
+    marketplace: import_cmd_ts4.positional({ type: import_cmd_ts4.optional(import_cmd_ts4.string), displayName: "marketplace" })
   },
   handler: async ({ marketplace }) => {
     try {
@@ -34001,13 +34795,36 @@ var pluginListCmd = import_cmd_ts3.command({
         console.error(`Marketplace '${marketplace}' not found`);
         process.exit(1);
       }
+      const userPlugins = await getInstalledUserPlugins();
+      const projectPlugins = await getInstalledProjectPlugins(process.cwd());
+      const installedMap = new Map;
+      for (const p of userPlugins) {
+        installedMap.set(`${p.name}@${p.marketplace}`, p);
+      }
+      for (const p of projectPlugins) {
+        installedMap.set(`${p.name}@${p.marketplace}`, p);
+      }
+      const versionMap = new Map;
+      for (const mp of toList) {
+        const version = await getMarketplaceVersion(mp.path);
+        versionMap.set(mp.name, version);
+      }
       if (isJsonMode()) {
         const allPlugins = [];
         const allWarnings = [];
         for (const mp of toList) {
           const result = await listMarketplacePlugins(mp.name);
+          const version = versionMap.get(mp.name) ?? null;
           for (const plugin of result.plugins) {
-            allPlugins.push({ name: plugin.name, marketplace: mp.name });
+            const key = `${plugin.name}@${mp.name}`;
+            const installed = installedMap.get(key);
+            allPlugins.push({
+              name: plugin.name,
+              marketplace: mp.name,
+              version,
+              scope: installed?.scope ?? null,
+              enabled: !!installed
+            });
           }
           for (const warning of result.warnings) {
             allWarnings.push(`${mp.name}: ${warning}`);
@@ -34025,29 +34842,52 @@ var pluginListCmd = import_cmd_ts3.command({
         return;
       }
       let totalPlugins = 0;
+      const allPluginEntries = [];
       for (const mp of toList) {
         const result = await listMarketplacePlugins(mp.name);
-        if (result.plugins.length === 0 && result.warnings.length === 0) {
-          console.log(`${mp.name}: (no plugins found)`);
-          continue;
-        }
-        console.log(`${mp.name}:`);
+        const version = versionMap.get(mp.name) ?? null;
         for (const warning of result.warnings) {
-          console.log(`  Warning: ${warning}`);
-        }
-        if (result.plugins.length === 0) {
-          console.log("  (no plugins found)");
+          allPluginEntries.push({
+            name: "",
+            marketplace: mp.name,
+            version,
+            installed: undefined,
+            warning
+          });
         }
         for (const plugin of result.plugins) {
-          console.log(`  - ${plugin.name}@${mp.name}`);
+          const key = `${plugin.name}@${mp.name}`;
+          const installed = installedMap.get(key);
+          allPluginEntries.push({
+            name: plugin.name,
+            marketplace: mp.name,
+            version,
+            installed
+          });
           totalPlugins++;
         }
-        console.log();
       }
       if (totalPlugins === 0) {
         console.log("No plugins found in registered marketplaces.");
-      } else {
-        console.log(`Total: ${totalPlugins} plugin(s)`);
+        return;
+      }
+      console.log(`Installed plugins:
+`);
+      for (const entry of allPluginEntries) {
+        if (entry.warning) {
+          console.log(`  Warning: ${entry.warning}`);
+          continue;
+        }
+        const isEnabled = !!entry.installed;
+        const statusIcon = isEnabled ? "✓" : "✗";
+        const statusText = isEnabled ? "enabled" : "disabled";
+        console.log(`  ❯ ${entry.name}@${entry.marketplace}`);
+        console.log(`    Version: ${entry.version ?? "unknown"}`);
+        if (entry.installed) {
+          console.log(`    Scope: ${entry.installed.scope}`);
+        }
+        console.log(`    Status: ${statusIcon} ${statusText}`);
+        console.log();
       }
     } catch (error) {
       if (error instanceof Error) {
@@ -34062,11 +34902,11 @@ var pluginListCmd = import_cmd_ts3.command({
     }
   }
 });
-var pluginValidateCmd = import_cmd_ts3.command({
+var pluginValidateCmd = import_cmd_ts4.command({
   name: "validate",
   description: buildDescription(pluginValidateMeta),
   args: {
-    path: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "path" })
+    path: import_cmd_ts4.positional({ type: import_cmd_ts4.string, displayName: "path" })
   },
   handler: async ({ path }) => {
     if (isJsonMode()) {
@@ -34081,12 +34921,12 @@ var pluginValidateCmd = import_cmd_ts3.command({
     console.log("(validation not yet implemented)");
   }
 });
-var pluginInstallCmd = import_cmd_ts3.command({
+var pluginInstallCmd = import_cmd_ts4.command({
   name: "install",
   description: buildDescription(pluginInstallMeta),
   args: {
-    plugin: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "plugin" }),
-    scope: import_cmd_ts3.option({ type: import_cmd_ts3.optional(import_cmd_ts3.string), long: "scope", short: "s", description: 'Installation scope: "project" (default) or "user"' })
+    plugin: import_cmd_ts4.positional({ type: import_cmd_ts4.string, displayName: "plugin" }),
+    scope: import_cmd_ts4.option({ type: import_cmd_ts4.optional(import_cmd_ts4.string), long: "scope", short: "s", description: 'Installation scope: "project" (default) or "user"' })
   },
   handler: async ({ plugin, scope }) => {
     try {
@@ -34139,13 +34979,13 @@ var pluginInstallCmd = import_cmd_ts3.command({
     }
   }
 });
-var pluginUninstallCmd = import_cmd_ts3.command({
+var pluginUninstallCmd = import_cmd_ts4.command({
   name: "uninstall",
   description: buildDescription(pluginUninstallMeta),
   aliases: ["remove"],
   args: {
-    plugin: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "plugin" }),
-    scope: import_cmd_ts3.option({ type: import_cmd_ts3.optional(import_cmd_ts3.string), long: "scope", short: "s", description: 'Installation scope: "project" (default) or "user"' })
+    plugin: import_cmd_ts4.positional({ type: import_cmd_ts4.string, displayName: "plugin" }),
+    scope: import_cmd_ts4.option({ type: import_cmd_ts4.optional(import_cmd_ts4.string), long: "scope", short: "s", description: 'Installation scope: "project" (default) or "user"' })
   },
   handler: async ({ plugin, scope }) => {
     try {
@@ -34275,13 +35115,14 @@ var pluginCmd = conciseSubcommands({
     uninstall: pluginUninstallCmd,
     marketplace: marketplaceCmd,
     list: pluginListCmd,
-    validate: pluginValidateCmd
+    validate: pluginValidateCmd,
+    skills: skillsCmd
   }
 });
 
 // src/cli/commands/self.ts
 init_execa();
-var import_cmd_ts4 = __toESM(require_cjs(), 1);
+var import_cmd_ts5 = __toESM(require_cjs(), 1);
 
 // src/cli/metadata/self.ts
 var updateMeta = {
@@ -34319,12 +35160,12 @@ function detectPackageManager() {
 function getCurrentVersion() {
   return package_default.version;
 }
-var updateCmd = import_cmd_ts4.command({
+var updateCmd = import_cmd_ts5.command({
   name: "update",
   description: buildDescription(updateMeta),
   args: {
-    npm: import_cmd_ts4.flag({ long: "npm", description: "Force update using npm" }),
-    bun: import_cmd_ts4.flag({ long: "bun", description: "Force update using bun" })
+    npm: import_cmd_ts5.flag({ long: "npm", description: "Force update using npm" }),
+    bun: import_cmd_ts5.flag({ long: "bun", description: "Force update using bun" })
   },
   handler: async ({ npm, bun }) => {
     try {
@@ -34525,5 +35366,5 @@ if (agentHelp) {
   const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), exports_wizard));
   await runWizard2();
 } else {
-  import_cmd_ts5.run(app, finalArgs);
+  import_cmd_ts6.run(app, finalArgs);
 }